Une bibliothèque .NET pour les solutions techniques aux fichiers CSV : documentation chinoise CsvHelper

CsvHelper est une bibliothèque .NET permettant de lire et d'écrire des fichiers CSV. CsvHelper peut être téléchargé via le gestionnaire de packages de Visual Studio. Définition de mappage automatique : lorsqu'aucun fichier de mappage n'est fourni, la valeur par défaut est le mappage automatique et le mappage automatique sera mappé aux attributs de la classe dans l'ordre.

Adresse GitHub

Lire

Lire tous les enregistrements

var csv = new CsvReader( textReader );
var records = csv.GetRecords<MyClass>(); // 把 CSV 记录映射到 MyClass，返回的 records 是个 IEnumerable<T> 对象

Si vous souhaitez personnaliser la relation de mappage, vous pouvez voir la section de mappage ci-dessous.
Étant donné que les enregistrements sont un objet IEnumerable, un enregistrement sera renvoyé uniquement lors d'un accès, et un enregistrement sera renvoyé une fois consulté. Si vous souhaitez y accéder comme une liste, vous pouvez procéder comme suit :

var csv = new CsvReader( textReader );
var records = csv.GetRecords<MyClass>().ToList();

Lire manuellement les enregistrements

Vous pouvez lire les données de chaque ligne dans une boucle de ligne

var csv = new CsvReader( textReader );
while( csv.Read() )
{
    var record = csv.GetRecord<MyClass>();
}

Lire les champs individuels

var csv = new CsvReader( textReader );
while( csv.Read() )
{
    var intField = csv.GetField<int>( 0 );
    var stringField = csv.GetField<string>( 1 );
    var boolField = csv.GetField<bool>( "HeaderName" );
}

Si le type de lecture peut être différent de celui attendu, vous pouvez utiliser TryGetField

var csv = new CsvReader( textReader );
while( csv.Read() )
{
    int intField;
    if( !csv.TryGetField( 0, out intField ) )
    {
        // Do something when it can't convert.
    }
}

pour analyser

si vous voulez chaque Une ligne peut être renvoyée sous forme de chaîne à l'aide de CsvParser.

var parser = new CsvParser( textReader );
while( true )
{
    var row = parser.Read(); // row 是个字符串
    if( row == null )
    {
        break;
    }
}

Écrire

Écrire tous les enregistrements

var csv = new CsvWriter( textWriter );
csv.WriteRecords( records );

var csv = new CsvWriter( textWriter );
foreach( var item in list )
{
    csv.WriteRecord( item );
}

var csv = new CsvWriter( textWriter );
foreach( var item in list )
{
    csv.WriteField( "a" );
    csv.WriteField( 2 );
    csv.WriteField( true );
    csv.NextRecord();
}

Carte

Carte automatique

Lorsqu'aucun fichier de mappage n'est fourni, la valeur par défaut est le mappage automatique, qui sera mappé aux attributs de la classe dans l'ordre. Si l'attribut est une classe personnalisée, il continuera à être renseigné selon les attributs de cette classe personnalisée. Si une référence circulaire se produit, le mappage automatique s'arrête.

Mappage manuel

Si le fichier CSV et la classe personnalisée ne correspondent pas exactement, vous pouvez définir une classe correspondante pour le gérer.

public sealed class MyClassMap : CsvClassMap<MyClass>
{
    public MyClassMap()
    {
        Map( m => m.Id );
        Map( m = > m.Name );
    }
}

Cet article a été traduit par tangyikejun

Mappage de référence

Si l'attribut est une classe personnalisée qui correspond à plusieurs colonnes du fichier CSV, vous pouvez utiliser la référence cartographie.

public sealed class PersonMap : CsvClassMap<Person>
{
    public PersonMap()
    {
        Map( m => m.Id );
        Map( m => m.Name );
        References<AddressMap>( m => m.Address );
    }
}

public sealed class AddressMap : CsvClassMap<Address>
{
    public AddressMap()
    {
        Map( m => m.Street );
        Map( m => m.City );
        Map( m => m.State );
        Map( m => m.Zip );
    }
}

Spécification de l'indice

Vous pouvez spécifier le mappage par indice de colonne

public sealed class MyClassMap : CsvClassMap<MyClass>
{
    public MyClassMap()
    {
        Map( m => m.Id ).Index( 0 );
        Map( m => m.Name ).Index( 1 );
    }
}

Spécification du nom de colonne

Vous pouvez également spécifier le mappage par nom de la colonne, cela nécessite que le fichier csv ait un enregistrement d'en-tête, c'est-à-dire que la première ligne enregistre le nom de la colonne

public sealed class MyClassMap : CsvClassMap<MyClass>
{
    public MyClassMap()
    {
        Map( m => m.Id ).Name( "The Id Column" );
        Map( m => m.Name ).Name( "The Name Column" );
    }
}

Traitement du même nom

public sealed class MyClassMap : CsvClassMap<MyClass>
{
    public MyClassMap()
    {
        Map( m => m.FirstName ).Name( "Name" ).NameIndex( 0 );
        Map( m => m.LastName ).Name( "Name" ).NameIndex( 1 );
    }
}

Valeur par défaut

public sealed class MyClassMap : CsvClassMap<MyClass>
{
    public override void MyClassMap()
    {
        Map( m => m.Id ).Index( 0 ).Default( -1 );
        Map( m => m.Name ).Index( 1 ).Default( "Unknown" );
    }
}

Conversion de type

public sealed class MyClassMap : CsvClassMap<MyClass>
{
    public MyClassMap()
    {
        Map( m => m.Id ).Index( 0 ).TypeConverter<MyIdConverter>();
    }
}

Conversion de type facultative

Le convertisseur par défaut gérera la plupart de la conversion de type, mais nous devrons parfois apporter quelques petites modifications. À ce stade, vous pouvez essayer d'utiliser la conversion de type facultative.

public sealed class MyClassMap : CsvClassMap<MyClass>
{
    public MyClassMap()
    {
        Map( m => m.Description ).Index( 0 ).TypeConverterOption( CultureInfo.InvariantCulture ); // 
        Map( m => m.TimeStamp ).Index( 1 ).TypeConverterOption( DateTimeStyles.AdjustToUniversal ); // 时间格式转换
        Map( m => m.Cost ).Index( 2 ).TypeConverterOption( NumberStyles.Currency ); // 数值类型转换
        Map( m => m.CurrencyFormat ).Index( 3 ).TypeConverterOption( "C" );
        Map( m => m.BooleanValue ).Index( 4 ).TypeConverterOption( true, "sure" ).TypeConverterOption( false, "nope" ); // 内容转换
    }
}

ConvertUsing

public sealed class MyClassMap : CsvClassMap<MyClass>
{
    public MyClassMap()
    {
        // 常数
        Map( m => m.Constant ).ConvertUsing( row => 3 );
        // 把两列聚合在一起
        Map( m => m.Aggregate ).ConvertUsing( row => row.GetField<int>( 0 ) + row.GetField<int>( 1 ) );
        // Collection with a single value.
        Map( m => m.Names ).ConvertUsing( row => new List<string>{ row.GetField<string>( "Name" ) } );
        // Just about anything.
        Map( m => m.Anything ).ConvertUsing( row =>
        {
            // You can do anything you want in a block.
            // Just make sure to return the same type as the property.
        } );
    }
}

Mappage d'exécution

Des mappages peuvent être créés au moment de l'exécution.

var customerMap = new DefaultCsvClassMap();

// mapping holds the Property - csv column mapping 
foreach( string key in mapping.Keys )
{
    var columnName = mapping[key].ToString();

    if( !String.IsNullOrEmpty( columnName ) )
    {
        var propertyInfo = typeof( Customer ).GetType().GetProperty( key );
        var newMap = new CsvPropertyMap( propertyInfo );
        newMap.Name( columnName );
        customerMap.PropertyMaps.Add( newMap );
    }
}

csv.Configuration.RegisterClassMap(CustomerMap);

Cet article a été traduit par tangyikejun

Configuration

Autoriser les commentaires

// Default value
csv.Configuration.AllowComments = false;

Cartographie automatique

var generatedMap = csv.Configuration.AutoMap<MyClass>();

Cache

Cache pour lire et écrire dans TextReader ou TextWriter

// Default value
csv.Configuration.BufferSize = 2048;

Commentaires

La ligne commentée ne sera pas chargée dans

// Default value
csv.Configuration.Comment = '#';

Byte Count

enregistre le nombre d'octets actuellement lus. Configuration.Encoding doit être défini pour être cohérent avec le fichier CSV. Ce paramètre affectera la vitesse d’analyse.

// Default value
csv.Configuration.CountBytes = false;

Informations sur la culture

// Default value
csv.Configuration.CultureInfo = CultureInfo.CurrentCulture;

Séparateur

// Default value
csv.Configuration.Delimiter = ",";

Changement de numéro de colonne

S'il est activé, il sera lancé si le numéro de colonne change. CsvBadDataException

// Default value
csv.Configuration.DetectColumnCountChanges = false;

Encoding

// Default value
csv.Configuration.Encoding = Encoding.UTF8;

S'il y a un enregistrement d'en-tête

// Default value
csv.Configuration.HasHeaderRecord = true;

Ignorer les espaces dans les noms de colonnes

Si les espaces dans les noms de colonnes sont ignorés

// Default value
csv.Configuration.IgnoreHeaderWhiteSpace = false;

Ignorer l'accès privé

S'il faut ignorer l'accès privé lors de la lecture et de l'écriture

// Default value
csv.Configuration.IgnorePrivateAccessor = false;

Ignorer les exceptions de lecture

Une exception s'est produite lors de la lecture Continuez la lecture par la suite

// Default value
csv.Configuration.IgnoreReadingExceptions = false;

Ignorez les guillemets

Ne pas utiliser de guillemets comme caractères d'échappement

// Default value
csv.Configuration.IgnoreQuotes = false;

Que ce soit le nom de la colonne est sensible à la casse

// Default value
csv.Configuration.IsHeaderCaseSensitive = true;

Accès à la carte

Peut accéder au mappage de classes personnalisé

var myMap = csv.Configuration.Maps[typeof( MyClass )];

Balise de liaison d'attribut

Utilisée pour rechercher des attributs personnalisés classes

// Default value
csv.Configuration.PropertyBindingFlags = BindingFlags.Public | BindingFlags.Instance;

Cet article a été traduit par tang yi ke jun

Citation

La définition est utilisée pour échapper aux caractères d'échappement contenant des délimiteurs, des crochets ou des fins de ligne

// Default value
csv.Configuration.Quote = '"';

Guillemets pour tous les champs

S'il faut ajouter des guillemets pour tous les champs lors de l'écriture au format CSV. QuoteAllFields et QuoteNoFields ne peuvent pas être vrais en même temps.

// Default value
csv.Configuration.QuoteAllFields = false;

Tous les champs sans guillemets

QuoteAllFields et QuoteNoFields ne peuvent pas être vrais en même temps.

// Default value
csv.Configuration.QuoteNoFields = false;

Lire le rappel d'exception

csv.Configuration.ReadingExceptionCallback = ( ex, row ) =>
{
    // Log the exception and current row information.
};

Enregistrer le mappage de classe

Si le mappage de classe est utilisé, il doit être enregistré avant d'être réellement utilisé.

csv.Configuration.RegisterClassMap<MyClassMap>();
csv.Configuration.RegisterClassMap<AnotherClassMap>();

Ignorer les enregistrements vides

Si tous les champs sont vides, ils seront considérés comme des champs vides

// Default value
csv.Configuration.SkipEmptyRecords = false;

Couper les champs

Supprimer le vide caractères à la fin du contenu du champ.

// Default value
csv.Configuration.TrimFields = false;

Découper le nom de la colonne

// Default value
csv.Configuration.TrimHeaders = false;

Dissocier le mappage de classes

// Unregister single map.
csv.Configuration.UnregisterClassMap<MyClassMap>();
// Unregister all class maps.
csv.Configuration.UnregisterClassMap();

Si un champ vide génère une exception

// Default value
csv.Configuration.WillThrowOnMissingField = true;

Type Conversions

Les conversions de types sont le moyen utilisé par CsvHelper pour convertir des chaînes en types .NET (et vice versa).

Autres

Afficher les informations sur les exceptions

Exception.Data["CsvHelper"]

// Row: '3' (1 based)
// Type: 'CsvHelper.Tests.CsvReaderTests+TestBoolean'
// Field Index: '0' (0 based)
// Field Name: 'BoolColumn'
// Field Value: 'two'

DataReader et DataTable

Les objets DataReader sont écrits au format CSV

var hasHeaderBeenWritten = false;
while( dataReader.Read() )
{
    if( !hasHeaderBeenWritten )
    {
        for( var i = 0; i < dataReader.FieldCount; i++ )
        {
            csv.WriteField( dataReader.GetName( i ) );
        }
        csv.NextRecord();
        hasHeaderBeenWritten = true;
    }

    for( var i = 0; i < dataReader.FieldCount; i++ )
    {
        csv.WriteField( dataReader[i] );
    }
    csv.NextRecord();
}

DataTable Objet écrit en CSV

using( var dt = new DataTable() )
{
    dt.Load( dataReader );
    foreach( DataColumn column in dt.Columns )
    {
        csv.WriteField( column.ColumnName );
    }
    csv.NextRecord();

    foreach( DataRow row in dt.Rows )
    {
        for( var i = 0; i < dt.Columns.Count; i++ )
        {
            csv.WriteField( row[i] );
        }
        csv.NextRecord();
    }
}

CSV vers DataTable

while( csv.Read() )
{
    var row = dt.NewRow();
    foreach( DataColumn column in dt.Columns )
    {
        row[column.ColumnName] = csv.GetField( column.DataType, column.ColumnName );
    }
    dt.Rows.Add( row );
}

Articles associés :

.net CsvHelper 2.0

Documentation chinoise de l'API jQuery EasyUI - Documentation Documentation_jquery

Vidéos associées :

Documentation chinoise Ruby

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!