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 class LiquidityMap : ClassMap<Liquidity>

    {

        public LiquidityMap()

        {

            Map(m => m.Value);

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

        }

    }   

​

    public class TradeLogRecMap : ClassMap<TradeLogRec>

    {

        public TradeLogRecMap()

        {

            // Automap TradeLogRecMap

            AutoMap(CultureInfo.InvariantCulture); //CSVConfig was not defined in your question so I used CultureInfo.InvariantCulture instead.

            // 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()));

        }

    }   

​

    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 sb = new StringBuilder();

            using (var writer = new StringWriter(sb))

            using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))

            {

                csv.Context.RegisterClassMap<TradeLogRecMap>();

                csv.WriteRecords(records);

            }           

            var csvText = sb.ToString();

            Console.WriteLine(csvText);

​

            List<TradeLogRec> newRecords;

            using (var reader = new StringReader(csvText))

            using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))

            {

                csv.Context.RegisterClassMap<TradeLogRecMap>();

                csv.Context.RegisterClassMap<LiquidityMap>();

                newRecords = csv.GetRecords<TradeLogRec>().ToList();

            }           

​

            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;

        }

    }

​