C#

Richard Deeming wrote:

of that type available with prefixing them

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