C#

public class PriceConverter<T> : DefaultTypeConverter
{
    public override object ConvertFromString(string text, IReaderRow row, MemberMapData memberMapData)
    {
        var result = 0.00;
        if (text.StartsWith("$"))
        {
            double.TryParse(text.Substring(1, text.Length - 1), out result);<br />
        }
        else
        {
            result = double.Parse(text);
        }

        return result;              
    }        
}

Map(m => m.SoldFor).Index(25).TypeConverter<PriceConverter<double>>();

jkirkerx wrote:

Hope this helps somebody in the future

public class AmazonDateConverter<T> : DefaultTypeConverter
{
    public override object ConvertFromString(string text, IReaderRow row, MemberMapData memberMapData)
    {
        var ci = CultureInfo.GetCultureInfo("en-us");
        return DateTime.Parse(text, ci);
    }
}

public class AmazonPriceConverter<T> : DefaultTypeConverter
{
    public override object ConvertFromString(string text, IReaderRow row, MemberMapData memberMapData)
    {
        var result = 0.00;
        if (text.StartsWith("$"))
        {
            double.TryParse(text.Substring(1, text.Length - 1), out result);
        }
        else
        {
            double.TryParse(text, out result);
        }
        return result;
    }
}

public class EBayYesNoConverter<T> : DefaultTypeConverter
{
    public override object ConvertFromString(string text, IReaderRow row, MemberMapData memberMapData)
    {
        if (text.ToLower().Equals("yes"))
        {
            return true;
        }
        else if (text.ToLower().Equals("no"))
        {
            return false;
        }
        return false;
    }
}

using (TextReader reader = ...)
{
    reader.ReadLine();
    reader.ReadLine();
    
    using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
    {
        csv.Configuration.HasHeaderRecord = false;
        csv.Configuration.RegisterClassMap<FooMap>();
        var records = csv.GetRecords<Foo>()
        ...
    }
}

...

public class Foo
{
    public string SalesRecordNumber { get; set; }
    public int OrderNumber { get; set; }
    public string BuyerUsername { get; set; }
}

public class FooMap : ClassMap<Foo>
{
    public FooMap()
    {
        Map(m => m.SalesRecordNumber).Index(0);
        Map(m => m.OrderNumber).Index(1);
        Map(m => m.BuyerUsername).Index(2);  
    }
}

namespace MarketPlace.CsvParser
{
    public class EBayCsvParser
    {
        public static async Task<List<EBayCsvImport>> Import_EBayOrderFile(string appPath)
        {
            var pOrders = new List<EBayCsvImport>();

            try
            {
                using (var reader = new StreamReader(appPath))
                {
                    using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
                    {
                        csv.Configuration.Delimiter = ",";
                        csv.Configuration.Encoding = Encoding.UTF8;
                        csv.Configuration.MissingFieldFound = null;
                        csv.Configuration.HasHeaderRecord = false;
                        csv.Configuration.HeaderValidated = null;<br />
                        csv.Configuration.CultureInfo = CultureInfo.InvariantCulture;
                        csv.Configuration.TypeConverterOptionsCache.GetOptions(typeof(decimal)).NumberStyle = NumberStyles.AllowCurrencySymbol | NumberStyles.AllowThousands;
                        csv.Configuration.PrepareHeaderForMatch = (header, index) => header.ToLower();
                        csv.Configuration.RegisterClassMap<EBayCsvImportMap>();

                        // Skip the first two lines
                        // Comma's and header
                        reader.ReadLine();
                        reader.ReadLine();

                        csv.Read();<br />
                        pOrders = csv.GetRecords<EBayCsvImport>().ToList();
                        Console.Write(pOrders);
                    }
                }
            }
            catch (Exception ex)
            {
                Console.Write(ex.Message);
            }

            await Task.Delay(100);
            return pOrders;
        }
    }
}

Quote:

I have a Listener class that implements a delegate and do some stuff when receive the request.

1. Parsing of the HTTP request/response.
2. Security features and authentication.
3. Caching support
4. Publishing/hosting support with leading cloud hosting platforms

Quote:

Now im getting calls by postman in localhost, and don't know how to implement to get server calls (idk if need other application for this like dotnet server or idk).

Quote:

The calls is based in the appClientCode so i need to get only the client call can be more clients on but they din't notice about other calls.

public class BaseClass
{
    public class Data
    {
        public int data1 = 1;
        public int data2 = 1;
        public string data3 = "BaseString";
    }
    
    public Data Value { get; }
    
    public BaseClass()
    {
        Value = new Data();
    }
}

public class DerivedClass : BaseClass
{
    public class DerivedData : BaseClass.Data
    {
        public int data4 = 2;
        
        public DerivedData()
        {
            data1 = 2;
            data2 = 2;
            data3 = "DerivedString";
        }
    }
    
    public DerivedClass()
    {
        Value = new DerivedData();
    }
}

using System;
using System.IO;
using System.Xml.Serialization;

namespace TextToClasses
{
    public class BaseClass
    {
        public class Data
        {
            public int Data1;
            public int Data2;
            public string Data3;

            public Data()
            {
            }

            public Data(int data1, int data2, string data3)
            {
                Data1 = data1;
                Data2 = data2;
                Data3 = data3;
            }
        }

        public Data TheData;

        public bool Save(string Filename, Data data)
        {
            var xs = new XmlSerializer(data.GetType());

            using (TextWriter sw = new StreamWriter(Filename))
            {
                xs.Serialize(sw, data);
            }

            return File.Exists(Filename);
        }

        public Data Load(string Filename, Type type)
        {
            Data rslt;

            var xs = new XmlSerializer(type);

            using (var sr = new StreamReader(Filename))
            {
                rslt = (Data) xs.Deserialize(sr);
            }

            return rslt;
        }
    }

    public class DerivedClass : BaseClass
    {
        public class DerivedData : BaseClass.Data
        {
            public int Data4;

            public DerivedData()
            {
            }

            public DerivedData(int data4, int data1, int data2, string data3) : base(data1, data2, data3)
            {
                Data4 = data4;
            }
        }
    }
}

BaseClass bc = new BaseClass();
bc.TheData = new BaseClass.Data(1,1,"BaseString");

bc.Save(@"C:\Users\test_user\Desktop\Basedata.xml", bc.TheData);

var bcdata = bc.Load(@"C:\Users\test_user\Desktop\Basedata.xml", bc.TheData.GetType());

DerivedClass dc = new DerivedClass();
dc.TheData = new DerivedClass.DerivedData(4, 2, 2, "DerivedString");

dc.Save(@"C:\Users\test_user\Desktop\Deriveddata.xml", dc.TheData);

var dcdata = dc.Load(@"C:\Users\test_user\Desktop\Deriveddata.xml", dc.TheData.GetType());