How to use EnumConverter with CsvHelper

Question

I'm using CsvHelper to serialize a class to csv file - until here everything works well.

Now I'm trying to find a way to convert the class's enum properties to their int value in the csv, so I could use the CSV for bulk insert later.

I found out the EnumConverter class in CsvHelper but I can't figure out how to properly use it, as all my tries are failing.

Here is my mapping class code

 public sealed class MyMapping : CsvClassMap<TradingCalendarException>
    {
        public MyMapping()
        {
            EnumConverter enumConverter = new EnumConverter(typeof(CalendarExceptionEntityType));

            Map(m => m.ExceptionEntityType).Index(0).Name("EXCEPTION_ENTITY_TYPE").TypeConverter(enumConverter);
            Map(m => m.ExceptionEntityIdentifier).Index(1).Name("EXCEPTION_ENTITY_IDENTIFIER");
            Map(m => m.OptionType).Index(2).Name("OPTION_TYPE");
            Map(m => m.StartDatetime).Index(3).Name("EXCEPTION_START_DATETIME");
            Map(m => m.EndDatetime).Index(4).Name("EXCEPTION_END_DATETIME");
            Map(m => m.DataSourceType).Index(5).Name("DATA_SOURCE_TYPE");
            Map(m => m.Description).Index(6).Name("DESCRIPTION");
        }
    }

and the writing part

using (StreamWriter file = new StreamWriter(filePath, false, Encoding.UTF8))
        {
            CsvWriter writer = new CsvWriter(file);
            MyMapping mapping = new MyMapping();
            writer.Configuration.RegisterClassMap(mapping);

            writer.WriteRecords(calendarExceptionList);
        }

The rest of the mapping (indexing and naming) is working, it's just the EnumConverter that doesn't do any change.

I didn't find any examples online.

Thank you!

Answer 1

This is the solution I made:

public class CalendarExceptionEnumConverter<T> : DefaultTypeConverter  where T : struct
    {
        public override string ConvertToString(TypeConverterOptions options, object value)
        {
            T result;
            if(Enum.TryParse<T>(value.ToString(),out result))
            {
                return (Convert.ToInt32(result)).ToString();
            }

            throw new InvalidCastException(String.Format("Invalid value to EnumConverter. Type: {0} Value: {1}",typeof(T),value));
        }
    }

and used it as the following:

Map(m => m.ExceptionEntityType).TypeConverter<CalendarExceptionEnumConverter<CalendarExceptionEntityType>>();

Answer 2

I used Yarimi's solution, but found it can't read the enum value back from the .csv (can write ok)

my solution is to make the class extend from EnumTypeConverter, not DefaultTypeConverter.

here is the full code

    public class OurEnumConverter<T> : CsvHelper.TypeConversion.EnumConverter where T : struct
    {

        public OurEnumConverter(): base(typeof(T))
        { }

        public override string ConvertToString(CsvHelper.TypeConversion.TypeConverterOptions options, object value)
        {
            T result;
            if (Enum.TryParse<T>(value.ToString(), out result))
            {
                return (Convert.ToInt32(result)).ToString();
            }
            return base.ConvertToString(options, value);
            //throw new InvalidCastException(String.Format("Invalid value to EnumConverter. Type: {0} Value: {1}", typeof (T), value));
        }
        public override object ConvertFromString(TypeConverterOptions options, string text)
        {
            int parsedValue;
            //System.Diagnostics.Debug.WriteLine($"{typeof(T).Name} = {text}");
            if (Int32.TryParse(text, out parsedValue))
            {
                return (T)(object)parsedValue;
            }
            return base.ConvertFromString(options, text);
            //throw new InvalidCastException(String.Format("Invalid value to EnumConverter. Type: {0} Value: {1}", typeof(T), text));
        }

    }

and here is how it's used

public class TickTradeClassMap : CsvHelper.Configuration.CsvClassMap<TickData.TickTrade>
    {
        public TickTradeClassMap()
        {
            Map(m => m.price);
            Map(m => m.size);
            Map(m => m.exchange).TypeConverter<OurEnumConverter<ATExchangeEnum>>();
            Map(m => m.condition1).TypeConverter<OurEnumConverter<ATTradeConditionEnum>>();
        }
    }

Answer 3

Add a int property to your TradingCalendarException class that casts back and forth to your custom enum, CalendarExceptionEntityType, like:

public int ExceptionEntityTypeInt { 
    get { return (int)ExceptionEntityType; } 
    set { ExceptionEntityType = (CalendarExceptionEntityType)value; } 
}

Use Map(m => m.ExceptionEntityTypeInt).Index(0).Name("EXCEPTION_ENTITY_TYPE_INT") instead of your enum converter Map(m => m.ExceptionEntityType).Index(0).Name("EXCEPTION_ENTITY_TYPE").TypeConverter(new MyMapping())

Answer 4

This is how I did it for the latest version of CSV Helper which is 7.1.1:

public class AggregateEnumConverter<T> : EnumConverter where T : struct
{
    public AggregateEnumConverter() : base(typeof(T)) { }

    public override object ConvertFromString(string text, IReaderRow row, MemberMapData memberMapData)
    {
        if(!Enum.TryParse(text, out AggregateType aggregateType))
        {
            // This is just to make the user life simpler...
            if(text == "24HAVG")
            {
                return AggregateType._24HAVG;
            }

            // If an invalid value is found in the CSV for the Aggregate column, throw an exception...
            throw new InvalidCastException($"Invalid value to EnumConverter. Type: {typeof(T)} Value: {text}");
        }

        return aggregateType;
    }
}

Note: the code above is making use of C# 7 new inline out variables.
More info here: How should I convert a string to an enum in C#?

This is how you make use of the custom EnumConverter:

/// <summary>
/// Maps Tag class properties to the CSV columns' names
/// </summary>
public sealed class TagMap : ClassMap<Tag>
{
    public TagMap(ILogger<CsvImporter> logger)
    {
        Map(tag => tag.Aggregate).Name("aggregate").TypeConverter<AggregateEnumConverter<AggregateType>>();
    }
}