打开 VS.NET 2013 或更高版本
创建一个示例 VS.NET (.NET Framework 4.5) 控制台应用程序项目
通过程序包管理器控制台使用 Nuget 命令，根据适用的 .NET 版本安装 ChoETL
- Install-Package ChoETL.JSON
- Install-Package ChoETL.JSON.NETStandard
使用 ChoETL 命名空间

让我们从一个生成下面具有两列的 JSON 文件的简单示例开始。

列表 3.1 示例 JSON 数据文件（emp.json）

[
  {
    "Id": 1,
    "Name": "Mark"
  },
  {
    "Id": 2,
    "Name": "Jason"
  }
]

有多种方法可以以最少的设置创建 JSON 文件。

3.1. 快速写入 - 数据优先方法

这是 **零配置** 且最快捷的方法，可以立即创建 JSON 文件。不需要类型化的 POCO 对象。下面的示例代码演示了如何使用动态对象生成示例 JSON 文件。

列表 3.1.1 将对象列表写入 JSON 文件

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 ChoJSONWriter("emp.json"))
{
    parser.Write(objs);
}

在上面的示例中，我们一次性将动态对象列表提供给 JSONWriter，以便将它们写入 JSON 文件。

列表 3.1.2 将每个对象写入 JSON 文件

using (var parser = new ChoJSONWriter("emp.json"))
{
    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);
}

在上面的示例中，我们通过使用 `Write` 重载来控制构造并逐个将动态记录传递给 JSONWriter 来生成 JSON 文件。

3.3. 配置优先方法

在此模型中，我们定义了 JSON 配置，其中包含所有必要的参数以及生成示例 JSON 文件所需的 JSON 列。

列表 3.3.1 定义 JSON 配置

ChoJSONRecordConfiguration config = new ChoJSONRecordConfiguration();
config.JSONRecordFieldConfigurations.Add(new ChoJSONRecordFieldConfiguration("Id"));
config.JSONRecordFieldConfigurations.Add(new ChoJSONRecordFieldConfiguration("Name"));

在上面，该类定义了两个 JSON 属性，与示例 JSON 文件模板匹配。

列表 3.3.2 无 POCO 对象生成 JSON 文件

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 ChoJSONWriter("emp.json", config))
{
    parser.Write(objs);
}

上面的示例代码展示了如何使用预定义的 JSON 配置设置，从动态对象列表中生成 JSON 文件。在 JSONWriter 构造函数中，我们指定了 JSON 配置对象，以在创建文件时遵守 JSON 布局模式。如果 JSON 列的名称或数量有任何不匹配，它将被报告为错误并停止写入过程。

列表 3.3.3 使用 POCO 对象保存 JSON 文件

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 ChoJSONWriter<EmployeeRecSimple>("emp.json", config))
{
    parser.Write(objs);
}

上面的示例代码展示了如何使用 JSON 配置对象从 POCO 对象列表中生成 JSON 文件。在 JSONWriter 构造函数中，我们指定了 JSON 配置对象。

3.4. 代码优先声明式配置

这是将 POCO 实体类与声明式 JSON 配置参数相结合的方法。`id` 是必需的列，`name` 是可选的值列，默认值为 “XXXX”。如果 `name` 不存在，则使用默认值。

清单 3.4.1 定义 POCO 对象

public class EmployeeRec
{
    [ChoJSONRecordField]
    [Required]
    public int? Id
    {
        get;
        set;
    }

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

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

上面的代码说明了定义 POCO 对象以及生成 JSON 文件所需的必要属性。第一项为每个记录字段定义一个属性，并使用 ChoJSONRecordFieldAttribute 来限定 JSON 记录映射。`Id` 是一个必需的属性。我们使用 RequiredAttribute 对其进行了装饰。`Name` 使用 DefaultValueAttribute 指定了默认值。这意味着，如果对象中未设置 `Name` 值，JSONWriter 将将默认值 'XXXX' 写入文件。

这非常简单，并且可以立即保存 JSON 数据。

列表 3.4.2 使用 POCO 对象保存 JSON 文件

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

EmployeeRec rec1 = new EmployeeRec();
rec1.Id = 1;
rec1.Name = "Mark";
objs.Add(rec1);
 
EmployeeRec rec2 = new EmployeeRec();
rec2.Id = 2;
rec2.Name = "Jason";
objs.Add(rec2);
 
using (var parser = new ChoJSONWriter<EmployeeRec>("emp.json"))
{
    parser.Write(objs);
}

我们首先创建一个 ChoJSONWriter 对象的新实例。仅此而已。生成 JSON 数据的繁重工作由写入器在后台完成。

默认情况下，JSONWriter 在保存 JSON 文件时会发现并使用默认配置参数。这些可以根据您的需要覆盖。以下部分将详细介绍每个配置属性。

4. 写入所有记录

它就像设置与 JSON 文件结构匹配的 POCO 对象，构造对象列表，然后将其传递给 JSONWriter 的 Write 方法一样简单。这将一次性将整个对象列表写入 JSON 文件。

列表 4.1 写入 JSON 文件

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

using (var parser = new ChoJSONWriter<EmployeeRec>("emp.json"))
{
    parser.Write(objs);
}

或

列表 4.2 写入 JSON 文件流

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

using (var tx = File.OpenWrite("emp.json"))
{
    using (var parser = new ChoJSONWriter<EmployeeRec>(tx))
    {
        parser.Write(objs);
    }
}

这种模型使您的代码优雅、整洁、易于阅读和维护。

5. 手动写入记录

当 POCO 对象以非连接方式构造时，这是写入每个单独记录到 JSON 文件的替代方法。

列表 5.1 写入 JSON 文件

var writer = new ChoJSONWriter<EmployeeRec>("emp.json");

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

EmployeeRec rec2 = new EmployeeRec();
rec1.Id = 2;
rec1.Name = "Jason"; 

writer.Write(rec2);

6. 自定义 JSON 记录

使用 ChoJSONRecordObjectAttribute，您可以以声明方式自定义 POCO 实体对象。

图 6.1 为每条记录自定义 POCO 对象

[ChoJSONRecordObject]
public class EmployeeRec
{
    [ChoJSONRecordField]
    public int Id { get; set; }
    [ChoJSONRecordField]
    [Required]
    [DefaultValue("ZZZ")]
    public string Name { get; set; }
}

以下是用于自定义文件上的 JSON 加载操作的可用属性

Culture - 用于读取和写入的文化信息。
ColumnCountStrict - 此标志指示如果 JSON 字段配置与数据对象成员不匹配，是否应抛出异常。
NullValue - 特殊的 `null` 值文本，在记录级别期望将其作为 JSON 文件中的 `null` 值处理。
ErrorMode - 此标志指示在写入过程中是否应抛出异常，并且预期的字段未能写入。可以按属性覆盖。可能的值是
- IgnoreAndContinue - 忽略错误，跳过记录并继续处理下一条。
- ReportAndContinue - 如果 POCO 实体是 IChoNotifyRecordWrite 类型，则向其报告错误。
- ThrowAndStop - 抛出错误并停止执行。
IgnoreFieldValueMode - 不适用
ObjectValidationMode - 一个标志，告知读取器关于记录对象要执行的验证类型。可能的值是
- Off - 不执行对象验证。(默认)
- MemberLevel - 在写入每个 JSON 属性到文件之前执行的验证
- ObjectLevel - 在将所有 POCO 属性写入文件之前执行的验证

7. 自定义 JSON 字段

对于每个 JSON 列，您可以使用 ChoJSONRecordFieldAttribute 在 POCO 实体属性中指定映射。

列表 7.1 自定义 POCO 对象以匹配 JSON 列

public class EmployeeRec
{
    [ChoJSONRecordField]
    public int Id { get; set; }
    [ChoJSONRecordField]
    [Required]
    [DefaultValue("ZZZ")]
    public string Name { get; set; }
}

以下是您可以为每个属性添加自定义的可用成员

FieldName - JSON 字段名。如果未指定，则将使用 POCO 对象属性名作为字段名。
Size - JSON 列值的大小
NullValue - 特殊的 `null` 值文本，在字段级别期望将其作为 JSON 文件中的 `null` 值处理。
ErrorMode - 此标志指示在写入过程中是否应抛出异常，并且预期的字段未能转换和写入。可能的值是
- IgnoreAndContinue - 忽略错误，继续加载记录的其他属性。
- ReportAndContinue - 如果 POCO 实体是 IChoRecord 类型，则向其报告错误。
- ThrowAndStop - 抛出错误并停止执行。

7.1. 默认值

任何 POCO 实体属性都可以使用 System.ComponentModel.DefaultValueAttribute 指定默认值。当 JSON 值 `null`（由 IgnoreFieldValueMode 控制）时，将使用此值进行写入。

7.2. 后备值

任何 POCO 实体属性都可以使用 ChoETL.ChoFallbackValueAttribute 指定回退值。当属性写入 JSON 失败时，将使用此值。 `Fallback` 值仅在 `ErrorMode` 为 `IgnoreAndContinue` 或 `ReportAndContinue` 时设置。

7.3. 类型转换器

大多数原始类型会自动转换为字符串/文本并保存到 JSON 文件。如果 JSON 字段的值未自动转换为文本值，您可以指定自定义/.NET 内置转换器来将值转换为文本。这些可以是 `IValueConverter`、`IChoValueConverter` 或 `TypeConverter` 转换器。

有几种方法可以为每个字段指定转换器

声明式方法
配置方法

7.3.1. 声明式方法

此模型仅适用于 POCO 实体对象。如果您有 POCO 类，可以为每个属性指定转换器来对它们进行必要的转换。下面的示例展示了如何做到这一点。

图 7.3.1.1 指定类型转换器

public class EmployeeRec
{
    [ChoJSONRecordField]
    [ChoTypeConverter(typeof(IntConverter))]
    public int Id { get; set; }
    [ChoJSONRecordField]
    [Required]
    [DefaultValue("ZZZ")]
    public string Name { get; set; }
}

图 7.3.1.2 IntConverter 实现

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");
    }
}

在上面的示例中，我们定义了自定义的 `IntConverter` 类。并展示了如何格式化 'Id' JSON 属性（带前导零）。

7.3.2. 配置式方法

此模型适用于动态和 POCO 实体对象。这使得可以在运行时将转换器附加到每个属性。这优先于 POCO 类上的声明式转换器。

列表 7.3.2.1 指定 TypeConverters

ChoJSONRecordConfiguration config = new ChoJSONRecordConfiguration();

ChoJSONRecordFieldConfiguration idConfig = new ChoJSONRecordFieldConfiguration("Id");
idConfig.AddConverter(new IntConverter());
config.JSONRecordFieldConfigurations.Add(idConfig);

config.JSONRecordFieldConfigurations.Add(new ChoJSONRecordFieldConfiguration("Name"));
config.JSONRecordFieldConfigurations.Add(new ChoJSONRecordFieldConfiguration("Name1"));

在上面，我们使用 ChoJSONRecordFieldConfiguration 对象中的 AddConverter 辅助方法构造并附加 `IntConverter` 到 'Id' 字段。

同样，如果您想从此对象中删除任何转换器，可以使用 ChoJSONRecordFieldConfiguration 对象上的 RemoveConverter。

7.3.3. 自定义值转换器方法

此方法允许使用 `Fluent` API 将值转换器附加到每个 JSON 成员。这是一种快速处理任何奇怪转换过程并避免创建值转换器类的快捷方式。

列表 7.3.3.1 POCO 类

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

使用 `Fluent` API，下面的示例展示了如何将值转换器附加到 `Id` 列。

列表 7.3.3.2 附加值转换器

using (var dr = new ChoJSONWriter<EmployeeRec>(@"Test.json")
    .WithField(c => c.Id, valueConverter: (v) => 
              ((int)value).ToString("C3", CultureInfo.CurrentCulture))
    )
{
    Console.WriteLine(rec);
}

7.4. 验证

JSONWriter 利用 `System.ComponentModel.DataAnnotations` 和 **Validation Block** 验证属性来指定 POCO 实体各个字段的验证规则。有关可用 `DataAnnotations` 验证属性的列表，请参阅 MSDN 网站。

图 7.4.1 在 POCO 实体中使用验证属性

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

在上面的示例中，我为 `Id` 属性使用了 `Range` 验证属性。为 `Name` 属性使用了 `Required` 验证属性。当 `Configuration.ObjectValidationMode` 设置为 `ChoObjectValidationMode.MemberLevel` 或 `ChoObjectValidationMode.ObjectLevel` 时，JSONWriter 在将数据保存到文件之前对其进行验证。

在某些情况下，您可能希望获得控制权并在 POCO 实体类中执行手动**自验证**。这可以通过继承 POCO 对象并实现 IChoValidatable 接口来实现。

图 7.4.2 在 POCO 实体上手动验证

[ChoJSONRecordObject]
public partial class EmployeeRec : IChoValidatable
{
    [ChoJSONRecordField]
    [ChoTypeConverter(typeof(IntConverter))]
    [Range(1, int.MaxValue, ErrorMessage = "Id must be > 0.")]
    [ChoFallbackValue(1)]
    public int Id { get; set; }
 
    [ChoJSONRecordField]
    [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;
    }
}

上面的示例展示了如何在 POCO 对象中实现自定义自验证。

IChoValidatable 接口公开以下方法

TryValidate - 验证整个对象，如果所有验证都通过，则返回 true。否则，返回 false。
TryValidateFor - 验证对象的特定属性，如果所有验证都通过则返回 true。否则，返回 false。

7.5. ChoIgnoreMember

如果您想在 `OptOut` 模式下从 JSON 解析中忽略 POCO 类成员，请使用 ChoIgnoreMemberAttribute 对其进行装饰。下面的示例显示 `Title` 成员已从 JSON 加载过程中忽略。

列表 7.5.1 忽略成员

public class EmployeeRec
{
    public int Id { get; set; }
    public string Name { get; set; }
    [ChoIgnoreMember]
    public string Title { get; set; }
}

7.6. StringLength

在 `OptOut` 模式下，您可以使用 `System.ComponentModel.DataAnnotations.StringLengthAttribute` 指定 JSON 列的大小。

列表 7.6.1 指定 JSON 成员的大小

public class EmployeeRec
{
    public int Id { get; set; }
    [StringLength(25)]
    public string Name { get; set; }
    [ChoIgnoreMember]
    public string Title { get; set; }
}

7.6. Display

在 `OptOut` 模式下，您可以使用 `System.ComponentModel.DataAnnotations.DisplayAttribute` 指定映射到成员的 JSON 列的名称。

列表 7.6.1 指定 JSON 列的名称

public class EmployeeRec
{
    public int Id { get; set; }
    [Display(Name="FullName")]
    [StringLength(25)]
    public string Name { get; set; }
    [ChoIgnoreMember]
    public string Title { get; set; }
}

7.7. DisplayName

在 `OptOut` 模式下，您可以使用 `System.ComponentModel.DataAnnotations.DisplayNameAttribute` 指定映射到成员的 JSON 列的名称。

列表 7.7.1 指定 JSON 列的名称

public class EmployeeRec
{
    public int Id { get; set; }
    [Display(Name="FullName")]
    [StringLength(25)]
    public string Name { get; set; }
    [ChoIgnoreMember]
    public string Title { get; set; }
}

8. 回调机制

JSONWriter 开箱即用提供行业标准的 JSON 数据文件生成，可满足大多数需求。如果生成过程无法满足您的任何需求，您可以使用 JSONWriter 提供的回调机制来处理这种情况。为了参与回调机制，您可以使用以下模型之一

使用 JSONWriter 通过 IChoWriter 接口公开的事件处理程序
使 POCO 实体对象继承自 IChoNotifyRecordWrite / IChoNotifyFileWrite / IChoNotifyRecordFieldWrite 接口
使 `DataAnnotation` 的 `MetadataType` 类型对象通过 IChoNotifyRecordWrite / IChoNotifyFileWrite / IChoNotifyRecordFieldWrite 接口继承。

为了参与回调机制，POCO 实体对象或 `DataAnnotation` 的 `MetadataType` 类型对象必须继承 IChoNotifyRecordWrite 接口。

提示：从此接口方法中引发的任何异常都将被忽略。

IChoRecorder 公开了以下方法

BeginWrite - 在 JSON 文件写入开始时调用
EndWrite - 在 JSON 文件写入结束时调用
BeforeRecordWrite - 在写入 JSON 记录之前引发
AfterRecordWrite - 在写入 JSON 记录之后引发
RecordWriteError - 在写入 JSON 记录时发生错误时引发
BeforeRecordFieldWrite - 在写入 JSON 列值之前引发
AfterRecordFieldWrite - 在写入 JSON 列值之后引发
RecordFieldWriteError - 在写入 JSON 列值时发生错误时引发

IChoNotifyRecordWrite 公开了以下方法

BeforeRecordWrite - 在写入 JSON 记录之前引发
AfterRecordWrite - 在写入 JSON 记录之后引发
RecordWriteError - 在写入 JSON 记录时发生错误时引发

IChoNotifyFileWrite 公开了以下方法

BeginWrite - 在 JSON 文件写入开始时调用
EndWrite - 在 JSON 文件写入结束时调用

IChoNotifyRecordFieldWrite 公开了以下方法

BeforeRecordFieldWrite - 在写入 JSON 列值之前引发
AfterRecordFieldWrite - 在写入 JSON 列值之后引发
RecordFieldWriteError - 在写入 JSON 列值时发生错误时引发

IChoNotifyFileHeaderArrange 公开了以下方法

FileHeaderArrange - 在将 JSON 文件头写入文件之前引发，这是一个重新排列 JSON 列的机会

IChoNotifyFileHeaderWrite 公开了以下方法

FileHeaderWrite - 在将 JSON 文件头写入文件之前引发，这是一个自定义文件头的机会。

8.1 使用 JSONWriter 事件

这是最直接、最简单的方法，可以订阅回调事件并处理 JSON 文件解析中的异常情况。缺点是代码无法重用，这不像通过 POCO 记录对象实现 IChoNotifyRecordRead 那样。

下面的示例展示了如何使用 BeforeRecordLoad 回调方法来跳过以 '%' 字符开头的行。

列表 8.1.1 使用 JSONWriter 回调事件

static void IgnoreLineTest()
{
    using (var parser = new ChoJSONWriter("emp.json"))
    { 
        parser.BeforeRecordWrite += (o, e) =>
        {
            if (e.Source != null)
            {
                e.Skip = ((JObject)e.Source).Contains("name1");
            }
        };
        
        parser.Write(rec);
    }
}

同样，您也可以在 JSONWriter 中使用其他回调方法。

8.2 实现 IChoNotifyRecordWrite 接口

下面的示例展示了如何实现 IChoNotifyRecordWrite 接口以直接用于 POCO 类。

列表 8.2.1 直接 POCO 回调机制实现

[ChoJSONRecordObject]
public partial class EmployeeRec : IChoNotifyrRecordWrite
{
    [ChoJSONRecordField]
    [ChoTypeConverter(typeof(IntConverter))]
    [Range(1, int.MaxValue, ErrorMessage = "Id must be > 0.")]
    [ChoFallbackValue(1)]
    public int Id { get; set; }
    
    [ChoJSONRecordField]
    [Required]
    [DefaultValue("ZZZ")]
    [ChoFallbackValue("XXX")]
    public string Name { get; set; }

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

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

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

下面的示例展示了如何通过在 POCO 类上使用 MetadataTypeAttribute 来附加 Metadata 类。

列表 8.2.2 基于 MetaDataType 的回调机制实现

[ChoJSONRecordObject]
public class EmployeeRecMeta : IChoNotifyRecordWrite
{
    [ChoJSONRecordField]
    [ChoTypeConverter(typeof(IntConverter))]
    [Range(1, int.MaxValue, ErrorMessage = "Id must be > 0.")]
    [ChoFallbackValue(1)]
    public int Id { get; set; }

    [ChoJSONRecordField]
    [Required]
    [DefaultValue("ZZZ")]
    [ChoFallbackValue("XXX")]
    public string Name { get; set; }

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

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

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

[MetadataType(typeof(EmployeeRecMeta))]
public partial class EmployeeRec
{
    public int Id { get; set; }
    public string Name { get; set; }
}

下面的示例展示了如何通过在 POCO 类上使用 ChoMetaDataRefTypeAttribute 来为密封类或第三方 POCO 类附加 Metadata 类。

列表 8.2.2 基于 MetaDataType 的回调机制实现

[ChoMetadataRefType(typeof(EmployeeRec))]
[ChoJSONRecordObject]
public class EmployeeRecMeta : IChoNotifyRecordWrite
{
    [ChoJSONRecordField]
    [ChoTypeConverter(typeof(IntConverter))]
    [Range(1, int.MaxValue, ErrorMessage = "Id must be > 0.")]
    [ChoFallbackValue(1)]
    public int Id { get; set; }

    [ChoJSONRecordField]
    [Required]
    [DefaultValue("ZZZ")]
    [ChoFallbackValue("XXX")]
    public string Name { get; set; }

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

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

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

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

8.3 BeginWrite

此回调在 JSON 文件写入 **开始时** 调用一次。`source` 是 JSON 文件的 `stream` 对象。在这里，您可以检查 `stream`，返回 `true` 继续 JSON 生成。返回 `false` 停止生成。

列表 8.3.1 BeginWrite 回调示例

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

8.4 EndWrite

此回调在 JSON 文件生成 **结束时** 调用一次。`source` 是 JSON 文件的 stream 对象。在这里，您可以检查 `stream`，对 `stream` 执行任何后续步骤。

列表 8.4.1 EndWrite 回调示例

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

8.5 BeforeRecordWrite

此回调在 **每个 POCO 记录对象写入 JSON 文件之前** 调用。`target` 是 POCO 记录对象的实例。`index` 是文件中的行索引。`source` 是 JSON 记录行。在这里，您可以检查 POCO 对象，并在需要时生成 JSON 记录行。

提示：如果您想跳过记录而不写入，请将 source 设置为 null。