C#

contents = await client.GetStringAsync(url);
var res2 = JsonConvert.DeserializeObject<RootObject>(contents.ToString());
if (180 == res2.content.Count)
{
    StoredDates.Add(date, contents);
    StoredDatesList = JsonConvert.SerializeObject(StoredDates, Formatting.Indented);
}

public static string StoredDatesList
        {
            get => Preferences.Get(nameof(StoredDatesList), string.Empty);
            set => Preferences.Set(nameof(StoredDatesList), value);
        }
        public static async Task<string> GetDraws(Uri url, string date)
        {
            var StoredDates = JsonConvert.DeserializeObject<Dictionary<string, string>>(StoredDatesList);
            var contents = string.Empty;
            var current = Connectivity.NetworkAccess;
            var client = new HttpClient();

            if (StoredDates != null)
                if (StoredDates.ContainsKey(date))
                {
                    contents = StoredDates[date];
                }
                else
                {
                    if (current != NetworkAccess.Internet)
                        return Helpers.Settings.Common_Error_NoInternetConnection;

                    contents = await DownloadResults(url, date, StoredDates, contents, client);
                }
            else
            {
                if (current != NetworkAccess.Internet)
                    return Helpers.Settings.Common_Error_NoInternetConnection;

                StoredDates = new Dictionary<string, string>();
                contents = await DownloadResults(url, date, StoredDates, contents, client);
            }
            return contents;
        }

        private static async Task<string> DownloadResults(Uri url, string date, Dictionary<string, string> StoredDates, string contents, HttpClient client)
        {
            contents = await client.GetStringAsync(url);
            var res2 = JsonConvert.DeserializeObject<RootObject>(contents.ToString());
            if (180 == res2.content.Count)
            {
                StoredDates.Add(date, contents);
                StoredDatesList = JsonConvert.SerializeObject(StoredDates, Formatting.Indented);
            }

            return contents;
        }

...
public const string Common_Error_NoInternetConnection = "Error_NoInternetConnection";

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