Cinchoo ETL – CSV Writer

1. Introduction
2. Requirement
3. “Hello World!” Sample
- 3.1. Quick write – Data First Approach
- 3.2. Code First Approach
- 3.3. Configuration First Approach
4. Writing All Records
5. Write Records Manually
6. Customize CSV Record
7. Customize CSV Header
8. Customize CSV Fields
- 8.1. DefaultValue
- 8.2. ChoFallbackValue
- 8.3. Type Converters
- 8.4. Validations
9. Excel Field Separator
10. Callback Mechanism
- 10.1 BeginWrite
- 10.2 EndWrite
- 10.3 BeforeRecordWrite
- 10.4 AfterRecordWrite
- 10.5 RecordWriteError
- 10.6 BeforeRecordFieldWrite
- 10.7 AfterRecordFieldWrite
- 10.8 RecordWriteFieldError
11. Customization
12. Using Dynamic Object
13. Exceptions
14. Tips
15. Using MetadataType Annotation
16. Configuration Choices
- 16.1 Manual Configuration
- 16.2 Auto Map Configuration
- 16.3 Attaching MetadataType class
17. ToText Helper Method
18. Writing DataReader Helper Method
19. Writing DataTable Helper Method
20. Advanced Topics
- 20.1 Override Converters Format Specs
- 20.2 Currency Support
- 20.3 Enum Support
- 20.4 Boolean Support
- 20.5 DateTime Support
21. Fluent API
- 21.1 WithDelimiter
- 21.2 WithFirstLineHeader
- 21.3 WithFields
- 21.4 WithField
- 21.5 QuoteAllFields

1. Introduction

ChoETL is an open source ETL (extract, transform and load) framework for .NET. It is a code based library for extracting data from multiple sources, transforming, and loading into your very own data warehouse in .NET environment. You can have data in your data warehouse in no time.

This article talks about using CSVRWriter component offered by ChoETL framework. It is a simple utility class to save CSV data to a file.

UPDATE: Corresponding CSVReader article can be found here.

Features:

Follows CSV standard file rules. Gracefully handles data fields that contain commas and line breaks.
In addition to comma, most delimiting characters can be used, including tab delimited fields.
Supports culture specific date, currency and number formats while generating files.
Supports different character encoding.
Provides fine control of date, currency, enum, boolean, number formats when writing files.
Detailed and robust error handling, allowing you to quickly find and fix problems.
Shorten your development time.

2. Requirement

This framework library is written in C# using .NET 4.5 Framework.

3. “Hello World!” Sample

Open VS.NET 2013 or higher
Create a sample VS.NET (.NET Framework 4.5) Console Application project
Install ChoETL via Package Manager Console using Nuget Command: Install-Package ChoETL
Use the ChoETL namespace

Let’s begin by looking into a simple example of generating the below CSV file having 2 columns

Listing 3.1 Sample CSV data file

1,Tom
2,Carl
3,Mark

There are number of ways you can get the CSV file be created with minimal setup.

3.1. Quick write – Data First Approach

This is the zero-config and quickest way to create CSV file in no time. No typed POCO object is needed. Sample code below shows how to generate sample CSV file using dynamic objects

Listing 3.1.1 Write list of objects to CSV file

List<ExpandoObject> objs = new List<ExpandoObject>();
dynamic rec1 = new ExpandoObject();
rec1.Id = 1;
rec1.Name = "Mark";
objs.Add(rec1);
 
dynamic rec2 = new ExpandoObject();
rec2.Id = 2;
rec2.Name = "Jason";
objs.Add(rec2);
 
using (var parser = new ChoCSVWriter("Emp.csv"))
{
    parser.Write(objs);
}

In the above sample, we give the list of objects to CSVWriter at one pass to write them to CSV file.

Listing 3.1.2 Write each object to CSV file

using (var parser = new ChoCSVWriter("Emp.csv"))
{
    dynamic rec1 = new ExpandoObject();
    rec1.Id = 1;
    rec1.Name = "Mark";
    parser.Write(item);

    dynamic rec1 = new ExpandoObject();
    rec1.Id = 2;
    rec1.Name = "Jason";
    parser.Write(item);
}

In the above sample, we take control of constructing, passing each and individual record to the CSVWriter to generate the CSV file using Write overload.

3.2. Code First Approach

This is another zeo-config way to generate CSV file using typed POCO class. First define a simple POCO class to match the underlying CSV file layout

Listing 3.2.1 Simple POCO entity class

public partial class EmployeeRecSimple
{
    public int Id { get; set; }
    public string Name { get; set; } 
}

In above, the POCO class defines two properties matching the sample CSV file template.

Listing 3.2.2 Saving to CSV file

List<EmployeeRecSimple> objs = new List<EmployeeRecSimple>();

EmployeeRecSimple rec1 = new EmployeeRecSimple();
rec1.Id = 1;
rec1.Name = "Mark";
objs.Add(rec1);
 
EmployeeRecSimple rec2 = new EmployeeRecSimple();
rec2.Id = 2;
rec2.Name = "Jason";
objs.Add(rec2);
 
using (var parser = new ChoCSVWriter<EmployeeRecSimple>("Emp.csv"))
{
    parser.Write(objs);
}

Above sample shows how to create CSV file from typed POCO class objects.

3.3. Configuration First Approach

In this model, we define the CSV configuration with all the necessary parameters along with CSV columns required to generate the sample CSV file.

Listing 3.3.1 Define CSV configuration

ChoCSVRecordConfiguration config = new ChoCSVRecordConfiguration();
config.CSVRecordFieldConfigurations.Add(new ChoCSVRecordFieldConfiguration("Id", 1));
config.CSVRecordFieldConfigurations.Add(new ChoCSVRecordFieldConfiguration("Name", 2));

In above, the class defines two CSV properties matching the sample CSV file template.

Listing 3.3.2 Generate CSV file without POCO object

List<ExpandoObject> objs = new List<ExpandoObject>();

dynamic rec1 = new ExpandoObject();
rec1.Id = 1;
rec1.Name = "Mark";
objs.Add(rec1);
 
dynamic rec2 = new ExpandoObject();
rec2.Id = 2;
rec2.Name = "Tom";
objs.Add(rec2);
 
using (var parser = new ChoCSVWriter("Emp.csv", config))
{
    parser.Write(objs);
}

The above sample code shows how to generate CSV file from list of dynamic objects using predefined CSV configuration setup. In the CSVWriter constructor, we specified the CSV configuration configuration object to obey the CSV layout schema while creating the file. If there are any mismatch in the name or count of CSV columns, will be reported as error and stops the writing process.

Listing 3.3.3 Saving CSV file with POCO object

List<EmployeeRecSimple> objs = new List<EmployeeRecSimple>();

EmployeeRecSimple rec1 = new EmployeeRecSimple();
rec1.Id = 1;
rec1.Name = "Mark";
objs.Add(rec1);
 
EmployeeRecSimple rec2 = new EmployeeRecSimple();
rec2.Id = 2;
rec2.Name = "Jason";
objs.Add(rec2);
 
using (var parser = new ChoCSVWriter<EmployeeRecSimple>("Emp.csv", config))
{
    parser.Write(objs);
}

Above sample code shows how to generate CSV file from list of POCO objects with CSV configuration object. In the CSVWriter constructor, we specified the CSV configuration configuration object.

3.4. Code First with declarative configuration

This is the combined approach to define POCO entity class along with attaching CSV configuration parameters declaratively. id is required column and name is optional value column with default value “XXXX“. If name is not present, it will take the default value.

Listing 3.4.1 Define POCO Object

public class EmployeeRec
{
    [ChoCSVRecordField(1)]
    [Required]
    public int? Id
    {
        get;
        set;
    }

    [ChoCSVRecordField(2)]
    [DefaultValue("XXXX")]
    public string Name
    {
        get;
        set;
    }

    public override string ToString()
    {
        return "{0}. {1}.".FormatString(Id, Name);
    }
}

The code above illustrates about defining POCO object with nessasary attributes required to generate CSV file. First thing defines property for each record field with ChoCSVRecordFieldAttribute to qualify for CSV record mapping. Each property must specify position in order to be mapped to CSV column. Position is 1 based. Id is a required property. We decorated it with RequiredAttribute. Name is given default value using DefaultValueAttribute. It means that if the Name value is not set in the object, CSVWriter spits the default value ‘XXXX’ to the file.

It is very simple and ready to save CSV data in no time.

Listing 3.4.2 Saving CSV file with POCO object

List<EmployeeRec> objs = new List<EmployeeRec>();

EmployeeRec rec1 = new EmployeeRec();
rec1.Id = 10;
rec1.Name = "Mark";
objs.Add(rec1);
 
EmployeeRec rec2 = new EmployeeRec();
rec2.Id = 200;
rec2.Name = "Lou";
objs.Add(rec2);
 
using (var parser = new ChoCSVWriter<EmployeeRec>("Emp.csv"))
{
    parser.Write(objs);
}

We start by creating a new instance of ChoCSVWriter object. That’s all. All the heavy lifting of genering CSV data from the objects is done by the writer under the hood.

By default, CSVWriter discovers and uses default configuration parameters while saving CSV file. These can be overridable according to your needs. The following sections will give you in-depth details about each configuration attributes.

4. Writing All Records

It is as easy as setting up POCO object match up with CSV file structure, construct the list of objects and pass it to CSVWriter’s Write method. This will write the entire list of objects into CSV file in one single call.

Listing 4.1 Write to CSV File

List<EmployeeRec> objs = new List<EmployeeRec>();
//Construct and attach objects to this list
...

using (var parser = new ChoCSVWriter<EmployeeRec>("Emp.csv"))
{
    parser.Write(objs);
}

or:

Listing 4.2 Writer to CSV file stream

List<EmployeeRec> objs = new List<EmployeeRec>();
//Construct and attach objects to this list
...

using (var tx = File.OpenWrite("Emp.csv"))
{
    using (var parser = new ChoCSVWriter<EmployeeRec>(tx))
    {
        parser.Write(objs);
    }
}

This model keeps your code elegant, clean, easy to read and maintain.

5. Write Records Manually

This is an alternative way to write each and individual record to CSV file in case when the POCO objects are constructed in a disconnected way.

Listing 5.1 Wrting to CSV file

var writer = new ChoCSVWriter<EmployeeRec>("Emp.csv");

EmployeeRec rec1 = new EmployeeRec();
rec1.Id = 10;
rec1.Name = "Mark";
 
writer.Write(rec1);

EmployeeRec rec2 = new EmployeeRec();
rec1.Id = 11;
rec1.Name = "Top"; 

writer.Write(rec2);

6. Customize CSV Record

Using ChoCSVRecordObjectAttribute, you can customize the POCO entity object declaratively.

Listing 6.1 Customizing POCO object for each record

[ChoCSVRecordObject(Encoding = "Encoding.UTF32", 
ErrorMode = ChoErrorMode.IgnoreAndContinue, IgnoreFieldValueMode = ChoIgnoreFieldValueMode.All)]
public class EmployeeRec
{
    [ChoCSVRecordField(1, FieldName = "id")]
    public int Id { get; set; }
    [ChoCSVRecordField(2, FieldName ="Name", QuoteField = true)]
    [Required]
    [DefaultValue("ZZZ")]
    public string Name { get; set; }
}

Here are the available attributes to carry out customization of CSV load operation on a file.

Delimiter – The value used to separate the fields in a CSV row. Default is Culture.TextInfo.ListSeparator used.
EOLDelimiter – The value used to separate CSV rows. Default is \r\n (NewLine).
Culture – The culture info used to read and write.
IgnoreEmptyLine – N/A.
Comments – N/A.
QuoteChar – The value used to escape fields that contain a delimiter, quote, or line ending.
QuoteAllFields – A flag that tells the writer whether all fields written should have quotes around them; regardless if the field contains anything that should be escaped.
Encoding – The encoding of the CSV file.
HasExcelSeperator – A flag that tells the writer to spit out the excel seperator information in the out file.
ColumnCountStrict – This flag indicates if an exception should be thrown if CSV field configuration mismatch with the data object members.
ColumnOrderStrict – N/A.
BufferSize – The size of the internal buffer that is used when reader is from the StreamWriter.
ErrorMode – This flag indicates if an exception should be thrown if writing and an expected field is failed to write. This can be overridden per property. Possible values are:
- IgnoreAndContinue – Ignore the error, record will be skipped and continue with next.
- ReportAndContinue – Report the error to POCO entity if it is of IChoNotifyRecordWrite type
- ThrowAndStop – Throw the error and stop the execution
IgnoreFieldValueMode – N/A.
ObjectValidationMode – A flag to let the reader know about the type of validation to be performed with record object. Possible values are:
- Off – No object validation performed. (Default)
- MemberLevel – Validation performed before each CSV property gets written to the file.
- ObjectLevel – Validation performed before all the POCO properties are written to the file.

7. Customize CSV Header

By attaching ChoCSVFileHeaderAttribute to POCO entity object declaratively, you can influence the writer to generate CSV header when creating CSV file.

Listing 6.1 Customizing POCO object for file header

[ChoCSVFileHeader]
public class EmployeeRec
{
    [ChoCSVRecordField(1, FieldName = "id")]
    public int Id { get; set; }
    [ChoCSVRecordField(2, FieldName ="Name", QuoteField = true)]
    [Required]
    [DefaultValue("ZZZ")]
    public string Name { get; set; }
}

Here are the available members to add some customization to it according to your need.

FillChar – Padding character used when size of the CSV column header is short of the column size (ChoCSVRecordFieldAttribute.Size or ChoCSVRecordFieldConfiguration.Size). Default is ‘\0’, padding will be off.
Justification – Column header alignment. Default is Left.
TrimOption – N/A.
Truncate – This flag tells that the writer to truncate the CSV column header value if it over the column size. Default is false.

8. Customize CSV Fields

For each CSV column, you can specify the mapping in POCO entity property using ChoCSVRecordFieldAttribute.

Listing 6.1 Customizing POCO object for CSV columns

[ChoCSVFileHeader]
public class EmployeeRec
{
    [ChoCSVRecordField(1, FieldName = "id")]
    public int Id { get; set; }
    [ChoCSVRecordField(2, FieldName ="Name", QuoteField = true)]
    [Required]
    [DefaultValue("ZZZ")]
    public string Name { get; set; }
}

Here are the available members to add some customization to it for each property:

FieldPosition – When mapping by position, you specify the index of the CSV column that you want to use for that property. It is 1 based.
FieldName – CSV Column name header. If not specified, POCO object property name will be used as column header.
FillChar – Padding character used when size of the CSV column value is short of the column size. Default is ‘\0’, padding will be off.
FieldValueJustification – Column value alignment. Default is Left.
FieldValueTrimOption – N/A.
Truncate – This flag tells that the writer to truncate the CSV column value if it over the column size. Default is false.
Size – Size of CSV column value.
QuoteField – A flag that tells the writer that the CSV column value is surrounded by quotes.
ErrorMode – This flag indicates if an exception should be thrown if writing and an expected field failed to convert and write. Possible values are:
- IgnoreAndContinue – Ignore the error and continue to load other properties of the record.
- ReportAndContinue – Report the error to POCO entity if it is of IChoRecord type.
- ThrowAndStop – Throw the error and stop the execution.
IgnoreFieldValueMode – N/A

8.1. DefaultValue

Any POCO entity property can be specified with default value using System.ComponentModel.DefaultValueAttribute. It is the value used to write when the CSV value null (controlled via IgnoreFieldValueMode).

8.2. ChoFallbackValue

Any POCO entity property can be specified with fallback value using ChoETL.ChoFallbackValueAttribute. It is the value used and set to the property when the CSV value failed to convert as text. Fallback value only set when ErrorMode is either IgnoreAndContinue or ReportAndContinue.

8.3. Type Converters

Most of the primitive types are automatically converted to string/text and save them to CSV file. If the value of the CSV field aren’t automatically be converted into the text value, you can specify a custom / built-in .NET converters to convert the value to text. These can be either IValueConverter or TypeConverter converters.

The methods to use to convert/format property values to text are IValueConverter.ConvertBack() or TypeConvert.ConvertTo().

Listing 8.3.1 Specifying type converters

[ChoCSVFileHeader]
public class EmployeeRec
{
    [ChoCSVRecordField(1, FieldName = "id")]
    [ChoTypeConverter(typeof(IntConverter))]
    public int Id { get; set; }
    [ChoCSVRecordField(2, FieldName ="Name", QuoteField = true)]
    [Required]
    [DefaultValue("ZZZ")]
    public string Name { get; set; }
}

Listing 8.3.2 IntConverter implementation

public class IntConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return value;
    }
 
    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        int intValue = (int)value;
        return intValue.ToString("D4");
    }
}

In the example above, we defined custom IntConverter class. And showed how to format ‘Id‘ CSV property with leading zeros.

8.4. Validations

CSVWriter leverages both System.ComponentModel.DataAnnotations and Validation Block validation attributes to specify validation rules for individual fields of POCO entity. Refer to the MSDN site for a list of available DataAnnotations validation attributes.

Listing 8.4.1 Using validation attributes in POCO entity

[ChoCSVFileHeader]
[ChoCSVRecordObject(Encoding = "Encoding.UTF32", ErrorMode = ChoErrorMode.IgnoreAndContinue,
       IgnoreFieldValueMode = ChoIgnoreFieldValueMode.All, ThrowAndStopOnMissingField = false)]
public partial class EmployeeRec
{
    [ChoCSVRecordField(1, FieldName = "id")]
    [ChoTypeConverter(typeof(IntConverter))]
    [Range(1, int.MaxValue, ErrorMessage = "Id must be > 0.")]
    [ChoFallbackValue(1)]
    public int Id { get; set; }
 
    [ChoCSVRecordField(2, FieldName = "Name")]
    [Required]
    [DefaultValue("ZZZ")]
    [ChoFallbackValue("XXX")]
    public string Name { get; set; }
}

In example above, used Range validation attribute for Id property. Required validation attribute to Name property. CSVWriter performs validation on them before saving the data to file when Configuration.ObjectValidationMode is set to ChoObjectValidationMode.MemberLevel or ChoObjectValidationMode.ObjectLevel.

Some cases, you may want to take control and perform manual self validation within the POCO entity class. This can be achieved by inheriting POCO object from IChoValidatable interface.

Listing 8.4.2 Manual validation on POCO entity

[ChoCSVFileHeader]
[ChoCSVRecordObject(Encoding = "Encoding.UTF32", ErrorMode = ChoErrorMode.IgnoreAndContinue,
       IgnoreFieldValueMode = ChoIgnoreFieldValueMode.All, ThrowAndStopOnMissingField = false)]
public partial class EmployeeRec : IChoValidatable
{
    [ChoCSVRecordField(1, FieldName = "id")]
    [ChoTypeConverter(typeof(IntConverter))]
    [Range(1, int.MaxValue, ErrorMessage = "Id must be > 0.")]
    [ChoFallbackValue(1)]
    public int Id { get; set; }
 
    [ChoCSVRecordField(2, FieldName = "Name")]
    [Required]
    [DefaultValue("ZZZ")]
    [ChoFallbackValue("XXX")]
    public string Name { get; set; }
 
    public bool TryValidate(object target, ICollection<ValidationResult> validationResults)
    {
        return true;
    }
 
    public bool TryValidateFor(object target, string memberName, ICollection<ValidationResult> validationResults)
    {
        return true;
    }
 
    public void Validate(object target)
    {
    }
 
    public void ValidateFor(object target, string memberName)
    {
    }
}

Sample above shows how to implement custom self-validation in POCO object.

IChoValidatable interface exposes below methods

TryValidate – Validate entire object, return true if all validation passed. Otherwise return false.
Validate – Validate entire object, throw exception if validation is not passed.
TryValidateFor – Validate specific property of the object, return true if all validation passed. Otherwise return false.
ValidateFor – Validate specific property of the object, throw exception if validation is not passed.

9. Excel Field Separator

By setting HasExcelSeperator declaratively on POCO object or ChoCSVRecordConfiguration.HasExcelSeperator to true to generate excel field separator in the data file.

Listing 9.1 Specifying HasExcelSeperator to POCO object declaratively

[ChoCSVFileHeader]
[ChoCSVRecordObject(HasExcelSeparator = true)]
public class EmployeeRec
{
    [ChoCSVRecordField(1)]
    [Required]
    [ChoFallbackValue(100)]
    [Range(100, 10000)]
    public int? Id
    {
        get;
        set;
    }
    [ChoCSVRecordField(2)]
    [DefaultValue("XXXX")]
    public string Name
    {
        get;
        set;
    }
 
    public override string ToString()
    {
        return "{0}. {1}.".FormatString(Id, Name);
    }
}

Listing 9.2 Specifying HasExcelSeperator via configuration

ChoCSVRecordConfiguration config = new ChoCSVRecordConfiguration();
config.CSVRecordFieldConfigurations.Add(new ChoCSVRecordFieldConfiguration("Id", 1));
config.CSVRecordFieldConfigurations.Add(new ChoCSVRecordFieldConfiguration("Name", 2));
config.HasExcelSeparator = true;
 
List<EmployeeRecSimple> objs = new List<EmployeeRecSimple>();
EmployeeRecSimple rec1 = new EmployeeRecSimple();
rec1.Id = 1;
rec1.Name = "Mark";
objs.Add(rec1);
 
EmployeeRecSimple rec2 = new EmployeeRecSimple();
rec2.Id = 2;
rec2.Name = "Jason";
objs.Add(rec2);
 
using (var parser = new ChoCSVWriter<EmployeeRecSimple>("Emp.csv", config))
{
    parser.Write(objs);
}

Listing 9.3 Sample CSV file with Excel field separator

sep=,
1,Mark 
2,Jason

10. Callback Mechanism

CSVWriter offers industry standard CSV data file generation out of the box to handle most of the needs. If the generation process is not handling any of your needs, you can use the callback mechanism offered by CSVWriter to handle such situations. In order to participate in the callback mechanism, Either POCO entity object or DataAnnotation’s MetadataType type object must be inherited by IChoNotifyRecordWrite interface.

Tip: Any exceptions raised out of these interface methods will be ignored.

IChoNotifyRecordWrite exposes the below methods:

BeginWrite – Invoked at the begin of the CSV file write
EndWrite – Invoked at the end of the CSV file write
BeforeRecordWrite – Raised before the CSV record write
AfterRecordWrite – Raised after CSV record write
RecordWriteError – Raised when CSV record errors out while writing
BeforeRecordFieldWrite – Raised before CSV column value write
AfterRecordFieldWrite – Raised after CSV column value write
RecordFieldWriteError – Raised when CSV column value errors out while writing

Listing 10.1 Direct POCO callback mechanism implementation

[ChoCSVFileHeader]
[ChoCSVRecordObject(Encoding = "Encoding.UTF32", ErrorMode = ChoErrorMode.IgnoreAndContinue,
       IgnoreFieldValueMode = ChoIgnoreFieldValueMode.All, ThrowAndStopOnMissingField = false)]
public partial class EmployeeRec : IChoNotifyrRecordWrite
{
    [ChoCSVRecordField(1, FieldName = "id")]
    [ChoTypeConverter(typeof(IntConverter))]
    [Range(1, int.MaxValue, ErrorMessage = "Id must be > 0.")]
    [ChoFallbackValue(1)]
    public int Id { get; set; }
    
    [ChoCSVRecordField(2, FieldName = "Name", QuoteField = true)]
    [Required]
    [DefaultValue("ZZZ")]
    [ChoFallbackValue("XXX")]
    public string Name { get; set; }

    public bool AfterRecordFieldWrite(object target, int index, string propName, object value)
    {
        throw new NotImplementedException();
    }

    public bool AfterRecordWrite(object target, int index, object source)
    {
        throw new NotImplementedException();
    }

    public bool BeforeRecordFieldWrite(object target, int index, string propName, ref object value)
    {
        throw new NotImplementedException();
    }

    public bool BeforeRecordWrite(object target, int index, ref object source)
    {
        throw new NotImplementedException();
    }

    public bool BeginWrite(object source)
    {
        throw new NotImplementedException();
    }

    public void EndWrite(object source)
    {
        throw new NotImplementedException();
    }

    public bool RecordFieldWriteError(object target, int index, string propName, object value, Exception ex)
    {
        throw new NotImplementedException();
    }

    public bool RecordWriteError(object target, int index, object source, Exception ex)
    {
        throw new NotImplementedException();
    }
}

Listing 10.2 MetaDataType based callback mechanism implementation

[ChoCSVFileHeader]
[ChoCSVRecordObject(Encoding = "Encoding.UTF32", ErrorMode = ChoErrorMode.IgnoreAndContinue,
       IgnoreFieldValueMode = ChoIgnoreFieldValueMode.All, ThrowAndStopOnMissingField = false)]
public class EmployeeRecMeta : IChoNotifyRecordWrite
{
    [ChoCSVRecordField(1, FieldName = "id")]
    [ChoTypeConverter(typeof(IntConverter))]
    [Range(1, int.MaxValue, ErrorMessage = "Id must be > 0.")]
    [ChoFallbackValue(1)]
    public int Id { get; set; }

    [ChoCSVRecordField(2, FieldName = "Name", QuoteField = true)]
    [Required]
    [DefaultValue("ZZZ")]
    [ChoFallbackValue("XXX")]
    public string Name { get; set; }
 
    public bool AfterRecordFieldWrite(object target, int index, string propName, object value)
    {
        throw new NotImplementedException();
    }

    public bool AfterRecordWrite(object target, int index, object source)
    {
        throw new NotImplementedException();
    }

    public bool BeforeRecordFieldWrite(object target, int index, string propName, ref object value)
    {
        throw new NotImplementedException();
    }

    public bool BeforeRecordWrite(object target, int index, ref object source)
    {
        throw new NotImplementedException();
    }

    public bool BeginWrite(object source)
    {
        throw new NotImplementedException();
    }

    public void EndWrite(object source)
    {
        throw new NotImplementedException();
    }

    public bool RecordFieldWriteError(object target, int index, string propName, object value, Exception ex)
    {
        throw new NotImplementedException();
    }

    public bool RecordWriteError(object target, int index, object source, Exception ex)
    {
        throw new NotImplementedException();
    }
} 

[MetadataType(typeof(EmployeeRecMeta))]
public partial class EmployeeRec
{
    [ChoCSVRecordField(1, FieldName = "id")]
    [ChoTypeConverter(typeof(IntConverter))]
    [Range(1, int.MaxValue, ErrorMessage = "Id must be > 0.")]
    [ChoFallbackValue(1)]
    public int Id { get; set; }
    
    [ChoCSVRecordField(2, FieldName = "Name", QuoteField = true)]
    [Required]
    [DefaultValue("ZZZ")]
    [ChoFallbackValue("XXX")]
    public string Name { get; set; }
}

10.1 BeginWrite

This callback invoked once at the beginning of the CSV file write. source is the CSV file stream object. In here you have chance to inspect the stream, return true to continue the CSV generation. Return false to stop the generation.

Listing 10.1.1 BeginWrite Callback Sample

public bool BeginWrite(object source)
{
    StreamReader sr = source as StreamReader;
    return true;
}

10.2 EndWrite

This callback invoked once at the end of the CSV file generation. source is the CSV file stream object. In here you have chance to inspect the stream, do any post steps to be performed on the stream.

Listing 10.2.1 EndWrite Callback Sample

public void EndWrite(object source)
{
    StreamReader sr = source as StreamReader;
}

10.3 BeforeRecordWrite

This callback invoked before each POCO record object is written to CSV file. target is the instance of the POCO record object. index is the line index in the file. source is the CSV record line. In here you have chance to inspect the POCO object, and generate the CSV record line if needed.

Tip: If you want to skip the record from writing, set the source to null.

Tip: If you want to take control of CSV record line generation, set the source to valid CSV record line text.