using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.IO;

using System.Data;

using System.ComponentModel.DataAnnotations;

using System.Globalization;

using System.Reflection;

using System.Collections.ObjectModel;

​

using NUnit.Framework; // Throws NUnit.Framework.AssertionException

​

using CsvHelper;

using CsvHelper.Configuration;

using CsvHelper.Configuration.Attributes;

using CsvHelper.Expressions;

using CsvHelper.TypeConversion;

​

using Newtonsoft.Json;

​

//https://stackoverflow.com/questions/68143146/csvhelper-with-non-default-constructor

​

    public class Liquidity

    {

        static readonly Dictionary<int, string> Values = new Dictionary<int, string> 

        { 

            {0, "None"}, 

            {1, "Added Liquidity"}, 

            {2, "Removed Liquidity"}, 

            {3, "Liquidity Routed Out" }

        };

​

        public Liquidity(int p) => this.Value = Values.ContainsKey(p) ? p : 0; 

​

        public int Value { get; set; }

​

        public override string ToString()

        {

            return Values[Value];

        }

    }

​

    public class Execution

    {

        public Liquidity LastLiquidity { get; set; }

​

        public Execution()

        {

            LastLiquidity = new Liquidity(0);

        }

    }

​

    public struct TradeLogRec

    {

        public Execution execution { set; get; }

    }

​

​

    public static class CsvSerializationHelper

    {

        public static CsvConfiguration CSVConfig => 

            new CsvConfiguration(CultureInfo.InvariantCulture)

            {

            };

        public class LiquidityMap : ClassMap<Liquidity>

        {

            public LiquidityMap()

            {

                Map(m => m.Value);

                Parameter("p").Name(nameof(Liquidity.Value));

            }

        }   

​

        public class TradeLogRecMap : ClassMap<TradeLogRec>

        {

            public TradeLogRecMap()

            {

                // Automap TradeLogRecMap

                AutoMap(CSVConfig);  // CSVConfig was not shown in your question, I used new CsvConfiguration(CultureInfo.InvariantCulture) { }

                // Get the reference map for Execution

                var executionRefMap = ReferenceMaps.Find<TradeLogRec>(m => m.execution);

                // Get its reference map for LastLiquidity

                var liquidityRefMap = executionRefMap.Data.Mapping.ReferenceMaps.Find<Execution>(m => m.LastLiquidity);

                // Remove the auto-generated reference map for LastLiquidity

                executionRefMap.Data.Mapping.ReferenceMaps.Remove(liquidityRefMap);

                // And add a reference map for LastLiquidity using LiquidityMap

                executionRefMap.Data.Mapping.ReferenceMaps.Add(new MemberReferenceMap(liquidityRefMap.Data.Member, new LiquidityMap()));

            }

        }   

        public static string SerializeToCsvString<TClass, TClassMap>(IEnumerable<TClass> records) where TClassMap : ClassMap<TClass>, new()

        {

            var sb = new StringBuilder();

            using (var writer = new StringWriter(sb))

            using (var csv = new CsvWriter(writer, CSVConfig))

            {

                csv.Context.RegisterClassMap<TClassMap>();

                csv.WriteRecords(records);

            }           

            return sb.ToString();

        }

        public static List<TClass> DeserializeFromCsvString<TClass, TClassMap>(string csvText) where TClassMap : ClassMap<TClass>, new()

        {

            using (var reader = new StringReader(csvText))

            using (var csv = new CsvReader(reader, CSVConfig))

            {

                csv.Context.RegisterClassMap<TClassMap>();

                return csv.GetRecords<TClass>().ToList();

            }           

        }

    }

​

    class TestClass

    {

        public static void Test()

        {

            var records = new List<TradeLogRec>

            {

                new TradeLogRec { execution = new Execution { LastLiquidity = new Liquidity(3) } },

                new TradeLogRec { execution = new Execution { LastLiquidity = new Liquidity(2) } },

                new TradeLogRec { execution = new Execution { LastLiquidity = new Liquidity(1) } },

                new TradeLogRec { execution = new Execution { LastLiquidity = new Liquidity(0) } },

            };

​

            var csvText = CsvSerializationHelper.SerializeToCsvString<TradeLogRec, CsvSerializationHelper.TradeLogRecMap>(records);

            Console.WriteLine(csvText);

​

            var newRecords = CsvSerializationHelper.DeserializeFromCsvString<TradeLogRec, CsvSerializationHelper.TradeLogRecMap>(csvText);

            Assert.AreEqual(JsonConvert.SerializeObject(records), JsonConvert.SerializeObject(newRecords));

        }   

    }

​

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: {0} ({1})", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , GetNetCoreVersion());

            Console.WriteLine("OS Version: {0}, NewLine: {1}", System.Environment.OSVersion, JsonConvert.SerializeObject(Environment.NewLine));

            Console.WriteLine("{0} version: {1}", typeof(CsvReader).Assembly.GetName().Name,  typeof(CsvReader).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

                Console.WriteLine("Failed with unhandled exception: ");

                Console.WriteLine(ex);

                throw;

            }

        }

        public static string GetNetCoreVersion()

        {

            //https://techblog.dorogin.com/how-to-detect-net-core-version-in-runtime-ecd65ad695be

            //

            var assembly = typeof(System.Runtime.GCSettings).GetTypeInfo().Assembly;

            var assemblyPath = assembly.Location.Split(new[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries);

            int netCoreAppIndex = Array.IndexOf(assemblyPath, "Microsoft.NETCore.App");

            if (netCoreAppIndex > 0 && netCoreAppIndex < assemblyPath.Length - 2)

                return assemblyPath[netCoreAppIndex + 1];

            return null;

        }

    }

​