CSVHelper: динамическая запись в CSV

Это некрасиво, но кажется, что это ClassMap сработает.

public sealed class SwitchingDataClassMap : ClassMap<SwitchingData>
{
    public SwitchingDataClassMap() 
    {
        Map(m => m.DateTime).Index(0);
        Map(m => m.EpisodeId).Index(1);
        Map(m => m.SourceState.TaskId).Name("SourceStateTaskId").Index(2);
        Map(m => m.SourceState.Name).Name("SourceStateName").Index(3);
        Map(m => ((ExternalStateInformation)m.SourceState).External)
            .Convert(args => args.Value.SourceState is ExternalStateInformation ?
                    ((ExternalStateInformation)args.Value.SourceState).External :
                    null)
            .Name("SourceStateExternal").Index(4);
        Map(m => m.TargetState.TaskId).Name("TargetStateTaskId").Index(5);
        Map(m => m.TargetState.Name).Name("TargetStateName").Index(6);
        Map(m => ((ExternalStateInformation)m.TargetState).External)
            .Convert(args => args.Value.TargetState is ExternalStateInformation ?
                    ((ExternalStateInformation)args.Value.TargetState).External :
                    null)
            .Name("TargetStateExternal").Index(7);
    }
}

В конце концов я написал свои собственные функции, записывающие заголовок и записи. Мой приведенный пример приведет к следующему заголовку:

DateTime,EpisodeId,SourceState_TaskId,SourceState_Name,SourceState_External,TargetState_TaskId,TargetState_Name,TargetState_External

Если бы TargetState реализовал интерфейс IStateInformation с другим дополнительным свойством, скажем Internal, заголовок выглядел бы так:

DateTime,EpisodeId,SourceState_TaskId,SourceState_Name,SourceState_External,TargetState_TaskId,TargetState_Name,TargetState_External,TargetState_Internal

Общая функция записи

private static void WriteToCSV<T>(string path, TypeConverterOptions options, List<T> data, FileMode mode)
{
    using (var stream = File.Open(path, mode))
    using (var writer = new StreamWriter(stream))
    using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
    {
        csv.Context.TypeConverterOptionsCache.AddOptions<DateTime>(options);
        csv.Context.TypeConverterOptionsCache.AddOptions<DateTime?>(options);

        List<Type> structure = GetStructureOfCSV(csv, data);

        if (mode == FileMode.Create)
        {
            WriteHeaderToCSV(csv, data);
            csv.NextRecord();
        }

        foreach (var record in data)
        {
            WriteRecordToCSV(csv, record, structure);
            csv.NextRecord();
        }
    }

    if (mode == FileMode.Create)
    {
        Debug.Log(String.Format("Write data to new file {0}", path));
    }
    else if (mode == FileMode.Append)
    {
        Debug.Log(String.Format("Write data to existing file {0}", path));
    }
}

Функция для получения структуры объекта

Это необходимо для записи значений по умолчанию вместо нулевых значений, что приведет к уменьшению количества полей CSV.

    private static List<Type> GetStructureOfCSV<T>(CsvWriter csv, List<T> data)
    {
        BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public;
        MemberInfo[] members = data[0].GetType().GetMemberInfos(bindingFlags);
        List<Type> structure = new List<Type>
        {
            data[0].GetType()
        };

        foreach (var thisVar in members)
        {
            if (!HasCSVHelperBuiltInConverter(thisVar.GetUnderlyingType()))
            {
                try
                {
                    List<T> records = data.Where(x => thisVar.GetValue(x) != null).ToList();
                    List<object> values = records.Select(x => thisVar.GetValue(x)).ToList();
                    structure = structure.Concat(GetStructureOfCSV(csv, values)).ToList();
                }
                catch (InvalidOperationException)
                {
                }
            }
        }

        return structure;
    }

Проверьте наличие ReferenceConverter

    private static bool HasCSVHelperBuiltInConverter(Type type)
    {
        return TypeDescriptor.GetConverter(type).GetType() != typeof(ReferenceConverter);
    }

Заголовок

    private static void WriteHeaderToCSV<T>(CsvWriter csv, List<T> data, string prefix = "")
    {
        BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public;
        MemberInfo[] members = data[0].GetType().GetMemberInfos(bindingFlags);

        foreach (var thisVar in members)
        {
            if (!HasCSVHelperBuiltInConverter(thisVar.GetUnderlyingType()))
            {
                try
                {
                    List<T> records = data.Where(x => thisVar.GetValue(x) != null).ToList();
                    List<object> values = records.Select(x => thisVar.GetValue(x)).ToList();
                    WriteHeaderToCSV(csv, values, thisVar.Name);
                }
                catch (InvalidOperationException)
                {
                    csv.WriteField(thisVar.Name);
                }
            }
            else
            {
                if (prefix != "" && prefix != null)
                {
                    csv.WriteField(string.Format("{0}_{1}", prefix, thisVar.Name));
                }
                else
                {
                    csv.WriteField(thisVar.Name);
                }
            }
        }
    }

Рекорды

    private static void WriteRecordToCSV(CsvWriter csv, object record, List<Type> structure)
    {
        BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public;
        MemberInfo[] members = record.GetType().GetMemberInfos(bindingFlags);
        List<Type> local_structure = new List<Type>(structure);

        local_structure.RemoveAt(0);

        foreach (var thisVar in members)
        {
            if (!HasCSVHelperBuiltInConverter(thisVar.GetUnderlyingType()))
            {
                if (thisVar.GetValue(record) != null)
                {
                    WriteRecordToCSV(csv, thisVar.GetValue(record), local_structure);
                }
                else
                {
                    object instance = Activator.CreateInstance(local_structure.First());
                    WriteRecordToCSV(csv, instance, local_structure);
                }
            }
            else
            {
                csv.WriteField(thisVar.GetValue(record));
            }
        }
    }