/// <summary>
/// 获取对帐单
/// </summary>
private List <WechatpayBillInfo> GetBills(string response, WechatpayDownloadBillRequest request)
{
var result = new List <WechatpayBillInfo>();
var tokenizer = new QuotedStringTokenizer(',');
var options = new CsvParserOptions(true, tokenizer);
var parser = new CsvParser <WechatpayBillInfo>(options, GetCsvMapping(request));
var readerOptions = new CsvReaderOptions(new[] { Environment.NewLine });
var records = parser.ReadFromString(readerOptions, response);
foreach (var record in records)
{
if (record.IsValid == false)
{
continue;
}
if (record.Result.TransactionTime == "交易时间")
{
continue;
}
if (record.Result.TransactionTime == "总交易单数")
{
break;
}
result.Add(record.Result);
}
return(result);
}
/// <summary>
/// From csv file, retrieve a bookmanifest to add to a list do bookmanifest later
/// </summary>
/// <param name="csvFilePath"></param>
/// <returns></returns>
public static List <BookManifest> CsvToManifestObject(String csvFilePath, List <BookManifest> booksManifests)
{
BookManifest bookManifest = new BookManifest();
CsvParserOptions csvParserOptions = new CsvParserOptions(true, ',');
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
CsvBookManifestMapping csvMapper = new CsvBookManifestMapping();
CsvParser <BookManifest> csvParser = new CsvParser <BookManifest>(csvParserOptions, csvMapper);
var result = csvParser.ReadFromFile(csvFilePath, Encoding.ASCII).ToList();
foreach (var item in result)
{
bookManifest = new BookManifest();
bookManifest.Title = item.Result.Title;
bookManifest.Description = item.Result.Description;
bookManifest.ISBN = item.Result.ISBN;
bookManifest.Author = item.Result.Author;
bookManifest.Genre = item.Result.Genre;
bookManifest.Pages = item.Result.Pages;
bookManifest.AgeRange = item.Result.AgeRange;
bookManifest.Price = item.Result.Price;
bookManifest.Quantity = item.Result.Quantity;
BookManifestOperations.CreateOrUpdateEntry(booksManifests, bookManifest);
}
return(booksManifests);
}
public static IEnumerable <SealedCards> GetCardsFromString(string fileContent)
{
var csvParserOptions = new CsvParserOptions(true, ',');
var csvMapper = new CsvSealedCardsMapping();
var csvParser = new CsvParser <SealedCards>(csvParserOptions, csvMapper);
var csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
var csvParseResult = csvParser.ReadFromString(csvReaderOptions, fileContent).ToList();
var sealedCards = csvParseResult.Select(r => r.Result).ToList();
var tempList = new List <SealedCards>();
foreach (var duplicates in sealedCards.Where(s => s.TotalQty > 1))
{
var totalQuantity = duplicates.TotalQty;
duplicates.TotalQty = 1;
duplicates.RegQty = 1;
duplicates.FoilQty = 1;
for (var x = 1; x < totalQuantity; x++)
{
tempList.Add(duplicates.ShallowCopy());
}
}
sealedCards.AddRange(tempList);
return(sealedCards);
}
public int TinyCsvParserBenchmark()
{
var totalLength = 0;
var csvParserOptions = new CsvParserOptions(false, ValueDelimeterChar, 4, true);
var csvReaderOptions = new CsvReaderOptions(RecordDelimeterStrings);
var csvMapper = new TinyCsvRecordMapping();
var csvParser = new CsvParser <Record>(csvParserOptions, csvMapper);
var results = csvParser.ReadFromString(csvReaderOptions, this.str);
foreach (var result in results)
{
var record = result.Result;
totalLength += record.Value0.Length;
totalLength += record.Value1.Length;
totalLength += record.Value2.Length;
totalLength += record.Value3.Length;
totalLength += record.Value4.Length;
totalLength += record.Value5.Length;
totalLength += record.Value6.Length;
totalLength += record.Value7.Length;
totalLength += record.Value8.Length;
totalLength += record.Value9.Length;
}
return(totalLength);
}
public void FloatArraysTest()
{
CsvParserOptions csvParserOptions = new CsvParserOptions(false, ';');
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
CsvMeasurementMapping csvMapper = new CsvMeasurementMapping();
CsvParser <Measurement> csvParser = new CsvParser <Measurement>(csvParserOptions, csvMapper);
var stringBuilder = new StringBuilder()
.AppendLine("Device1;1.0;2.0")
.AppendLine("Device2;3.0;4.0");
var result = csvParser
.ReadFromString(csvReaderOptions, stringBuilder.ToString())
.ToList();
Assert.AreEqual(2, result.Count);
Assert.IsTrue(result.All(x => x.IsValid));
Assert.AreEqual("Device1", result[0].Result.Id);
Assert.IsNotNull(result[0].Result.Values);
Assert.AreEqual(2, result[0].Result.Values.Length);
Assert.AreEqual(1.0, result[0].Result.Values[0]);
Assert.AreEqual(2.0, result[0].Result.Values[1]);
Assert.AreEqual("Device2", result[1].Result.Id);
Assert.IsNotNull(result[1].Result.Values);
Assert.AreEqual(2, result[1].Result.Values.Length);
Assert.AreEqual(3.0, result[1].Result.Values[0]);
Assert.AreEqual(4.0, result[1].Result.Values[1]);
}
public void CommentLineTest()
{
CsvParserOptions csvParserOptions = new CsvParserOptions(true, "#", new StringSplitTokenizer(new [] { ';' }, false));
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
CsvPersonMapping csvMapper = new CsvPersonMapping();
CsvParser <Person> csvParser = new CsvParser <Person>(csvParserOptions, csvMapper);
var stringBuilder = new StringBuilder()
.AppendLine("FirstName;LastName;BirthDate")
.AppendLine("#Philipp;Wagner;1986/05/12")
.AppendLine("Max;Mustermann;2014/01/01");
var result = csvParser
.ReadFromString(csvReaderOptions, stringBuilder.ToString())
.Where(x => x.IsValid)
.ToList();
Assert.AreEqual(1, result.Count);
Assert.AreEqual("Max", result[0].Result.FirstName);
Assert.AreEqual("Mustermann", result[0].Result.LastName);
Assert.AreEqual(2014, result[0].Result.BirthDate.Year);
Assert.AreEqual(1, result[0].Result.BirthDate.Month);
Assert.AreEqual(1, result[0].Result.BirthDate.Day);
}
static void Main(string[] args)
{
CsvParserOptions csvParserOptions = new CsvParserOptions(true, ';');
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
CsvCompanyMapping csvMapper = new CsvCompanyMapping();
CsvParser <Company> csvParser = new CsvParser <Company>(csvParserOptions, csvMapper);
// директория с исходником
string pathFrom = System.Configuration.ConfigurationManager.AppSettings["From"];
// директория для сохранения
string pathTo = System.Configuration.ConfigurationManager.AppSettings["To"];
string fileName = $"{pathFrom}list1.csv";
FileStream fStream = new FileStream(fileName, FileMode.Open);
string contents = null;
if (fStream.Length <= MAX_BUFFER_SIZE)
{
Byte[] bytes = new Byte[fStream.Length];
fStream.Read(bytes, 0, bytes.Length);
contents = enc8.GetString(bytes);
}
else
{
contents = ReadFromBuffer(fStream);
}
fStream.Close();
var list = csvParser.ReadFromString(csvReaderOptions, contents).ToList();
string appendText = GetResultString(list);
File.WriteAllText($"{pathTo}list1.html", appendText);
}
public void StringArrayMappingTest()
{
CsvParserOptions csvParserOptions = new CsvParserOptions(false, ';');
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
CsvStringArrayMapping csvMapper = new CsvStringArrayMapping();
CsvParser <string[]> csvParser = new CsvParser <string[]>(csvParserOptions, csvMapper);
var stringBuilder = new StringBuilder()
.AppendLine("Philipp;Wagner;1986/05/12")
.AppendLine("Max;Mustermann;2014/01/01");
var result = csvParser
.ReadFromString(csvReaderOptions, stringBuilder.ToString())
.ToList();
Assert.AreEqual(2, result.Count);
Assert.IsTrue(result.All(x => x.IsValid));
Assert.AreEqual("Philipp", result[0].Result[0]);
Assert.AreEqual("Wagner", result[0].Result[1]);
Assert.AreEqual("1986/05/12", result[0].Result[2]);
Assert.AreEqual("Max", result[1].Result[0]);
Assert.AreEqual("Mustermann", result[1].Result[1]);
Assert.AreEqual("2014/01/01", result[1].Result[2]);
}
private async void ExecuteDownloadData()
{
var eventResponse = "";
try {
var csvraw = await App.GetCSV("https://standards.ieee.org/develop/regauth/oui/oui.csv");//http://demo0369881.mockable.io/macdata
var options = new Options('"', '\\', ',');
var tokenizer = new RFC4180Tokenizer(options);
CsvParserOptions csvParserOptions = new CsvParserOptions(true, tokenizer);
OUIObjectMap csvMapper = new OUIObjectMap();
CsvParser <Mac> csvParser = new CsvParser <Mac>(csvParserOptions, csvMapper);
var opts = new CsvReaderOptions(new[] { Environment.NewLine });
var result = csvParser.ReadFromString(opts, csvraw);
System.Diagnostics.Debug.WriteLine("Writing to db...");
App.db.BeginTransaction();
foreach (var mac in result)
{
App.db.InsertOrReplace(mac.Result);
}
App.db.Commit();
System.Diagnostics.Debug.WriteLine("Writing to db OK");
eventResponse = DownloadEvent.EVENT_SUCCESS;
} catch (Exception e) {
eventResponse = DownloadEvent.EVENT_FAILED;
}
_eventAggregator.GetEvent <DownloadEvent>().Publish(eventResponse);
await _navigationService.ClearPopupStackAsync();
}
public void ExecuteWithMissingValuesTest()
{
CsvParserOptions options = new CsvParserOptions(true, ';');
CsvParser <SampleEntity> customCsvParser = new CsvParser <SampleEntity>(options, new PermissiveSampleEntityMapper());
var stringBuilder = new StringBuilder()
.AppendLine("FirstName;LastName;BirthDate")
.AppendLine("1;2;3")
.AppendLine("4");
var csvReaderOptions = new CsvReaderOptions(new [] { Environment.NewLine });
var result = customCsvParser
.ReadFromString(csvReaderOptions, stringBuilder.ToString())
.ToList();
Assert.AreEqual(2, result.Count);
Assert.IsTrue(result.All(x => x.IsValid));
Assert.AreEqual("1", result[0].Result.Value1);
Assert.AreEqual("2", result[0].Result.Value2);
Assert.AreEqual("3", result[0].Result.Value3);
Assert.AreEqual("4", result[1].Result.Value1);
Assert.AreEqual(null, result[1].Result.Value2);
Assert.AreEqual(null, result[1].Result.Value3);
}
public void SkipHeaderTest()
{
CsvParserOptions csvParserOptions = new CsvParserOptions(true, new[] { ';' });
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
CsvPersonMapping csvMapper = new CsvPersonMapping();
CsvParser <Person> csvParser = new CsvParser <Person>(csvParserOptions, csvMapper);
var stringBuilder = new StringBuilder()
.AppendLine("FirstName;LastName;BirthDate")
.AppendLine("Philipp;Wagner;1986/05/12")
.AppendLine("Max;Mustermann;2014/01/01");
var result = csvParser
.ReadFromString(csvReaderOptions, stringBuilder.ToString())
.ToList();
Assert.AreEqual(2, result.Count);
Assert.IsTrue(result.All(x => x.IsValid));
Assert.AreEqual("Philipp", result[0].Result.FirstName);
Assert.AreEqual("Wagner", result[0].Result.LastName);
Assert.AreEqual(1986, result[0].Result.BirthDate.Year);
Assert.AreEqual(5, result[0].Result.BirthDate.Month);
Assert.AreEqual(12, result[0].Result.BirthDate.Day);
Assert.AreEqual("Max", result[1].Result.FirstName);
Assert.AreEqual("Mustermann", result[1].Result.LastName);
Assert.AreEqual(2014, result[1].Result.BirthDate.Year);
Assert.AreEqual(1, result[1].Result.BirthDate.Month);
Assert.AreEqual(1, result[1].Result.BirthDate.Day);
}
public void WeirdDateTimeTest_TypeProviderBased()
{
var typeConverterProvider = new TypeConverterProvider()
.Override(new DateTimeConverter("yyyy###MM###dd"));
CsvParserOptions csvParserOptions = new CsvParserOptions(true, new[] { ';' });
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
CsvPersonMappingWithTypeConverterProvider csvMapper = new CsvPersonMappingWithTypeConverterProvider(typeConverterProvider);
CsvParser <Person> csvParser = new CsvParser <Person>(csvParserOptions, csvMapper);
var stringBuilder = new StringBuilder()
.AppendLine("FirstName;LastName;BirthDate")
.AppendLine("Philipp;Wagner;1986###05###12");
var result = csvParser
.ReadFromString(csvReaderOptions, stringBuilder.ToString())
.ToList();
Assert.AreEqual("Philipp", result[0].Result.FirstName);
Assert.AreEqual("Wagner", result[0].Result.LastName);
Assert.AreEqual(1986, result[0].Result.BirthDate.Year);
Assert.AreEqual(5, result[0].Result.BirthDate.Month);
Assert.AreEqual(12, result[0].Result.BirthDate.Day);
}
public void Issue60_TrailingComma_Test()
{
var csvParserOptions = new CsvParserOptions(false, '|');
var csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
var csvMapper = new TeacherEntityMapping();
var csvParser = new CsvParser <TeacherEntity>(csvParserOptions, csvMapper);
var stringBuilder = new StringBuilder()
.AppendLine(@"Johnson|Anne|110236|697125|1.00|Teacher|[email protected]");
var result = csvParser
.ReadFromString(csvReaderOptions, stringBuilder.ToString())
.ToList();
Assert.AreEqual(1, result.Count);
Assert.IsTrue(result.All(x => x.IsValid));
Assert.AreEqual("Johnson", result.First().Result.Col0);
Assert.AreEqual("Anne", result.First().Result.Col1);
Assert.AreEqual(110236, result.First().Result.Col2);
Assert.AreEqual(697125, result.First().Result.Col3);
Assert.AreEqual(1.00f, result.First().Result.Col4, 1e-3);
Assert.AreEqual("Teacher", result.First().Result.Col5);
Assert.AreEqual("*****@*****.**", result.First().Result.Col6);
}
public async Task <RegistryResponse> GetRegistryByID(int id)
{
CsvParserOptions csvParserOptions = new CsvParserOptions(false, ',');
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
RegistryMapping csvMapper = new RegistryMapping();
CsvParser <RegistryServices> csvParser =
new CsvParser <RegistryServices>(csvParserOptions, csvMapper);
RegistryResponse resultList = null;
var list = new List <RegistryResponse>();
try
{
string fileName = $"Doc//RegistryServices.csv";
var result = csvParser
.ReadFromFile(fileName, Encoding.UTF8).Skip(1)
.ToList();
result.ForEach(x =>
{
list.Add(new RegistryResponse
{
Id = Convert.ToInt32(x.Result.IdAgreement.ToString()),
NombreEmpresa = x.Result.NameEnterprise.ToString(),
EndpointUrl = new Uri($"http://{x.Result.EndpointUrl}"),
Formato = x.Result.FormatTransformation.ToString()
});
});
}
catch (Exception ex)
{
var error = ex.ToString();
}
return(list.Where(x => x.Id.Equals(id)).FirstOrDefault());
}
public void LastLineParseTest()
{
// We have a Line, where the last Column is "Empty":
string csvLine = "1\t2\t";
// We want to check with different Tokenizers:
CsvParser <TestEntity>[] csvParsers = new[]
{
GetRfc4180Parser(),
GetStringSplitParser()
};
// Now iterate over the Parsers:
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
foreach (var csvParser in csvParsers)
{
var result = csvParser
.ReadFromString(csvReaderOptions, csvLine)
.ToList();
Assert.AreEqual(1, result.Count);
Assert.IsTrue(result.All(x => x.IsValid));
Assert.AreEqual("1", result.First().Result.Column1);
Assert.AreEqual("2", result.First().Result.Column2);
Assert.AreEqual(string.Empty, result.First().Result.Column3);
}
}
public void QuotedStringTokenizerExampleTest()
{
CsvParserOptions csvParserOptions = new CsvParserOptions(true, string.Empty, new QuotedStringTokenizer(','));
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
CsvPersonMapping csvMapper = new CsvPersonMapping();
CsvParser <Person> csvParser = new CsvParser <Person>(csvParserOptions, csvMapper);
var stringBuilder = new StringBuilder()
.AppendLine("FirstNameLastName;BirthDate")
.AppendLine("\"Philipp,Wagner\",1986/05/12")
.AppendLine("\"Max,Mustermann\",2014/01/01");
var result = csvParser
.ReadFromString(csvReaderOptions, stringBuilder.ToString())
.ToList();
// Make sure we got 2 results:
Assert.AreEqual(2, result.Count);
// And all of them have been parsed correctly:
Assert.IsTrue(result.All(x => x.IsValid));
// Now check the values:
Assert.AreEqual("Philipp,Wagner", result[0].Result.FirstNameWithLastName);
Assert.AreEqual(1986, result[0].Result.BirthDate.Year);
Assert.AreEqual(5, result[0].Result.BirthDate.Month);
Assert.AreEqual(12, result[0].Result.BirthDate.Day);
Assert.AreEqual("Max,Mustermann", result[1].Result.FirstNameWithLastName);
Assert.AreEqual(2014, result[1].Result.BirthDate.Year);
Assert.AreEqual(1, result[1].Result.BirthDate.Month);
Assert.AreEqual(1, result[1].Result.BirthDate.Day);
}
public void MapUsingTest()
{
CsvParserOptions csvParserOptions = new CsvParserOptions(false, ';');
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
CsvMainClassMapping csvMapper = new CsvMainClassMapping();
CsvParser <MainClass> csvParser = new CsvParser <MainClass>(csvParserOptions, csvMapper);
var stringBuilder = new StringBuilder()
.AppendLine("X;Y;Z")
.AppendLine("A;B;C");
var result = csvParser
.ReadFromString(csvReaderOptions, stringBuilder.ToString())
.ToList();
Assert.AreEqual(2, result.Count);
Assert.IsFalse(result[0].IsValid);
Assert.IsTrue(result[1].IsValid);
Assert.AreEqual("A", result[1].Result.Property1);
Assert.IsNotNull(result[1].Result.SubClass);
Assert.AreEqual("B", result[1].Result.SubClass.Property2);
Assert.AreEqual("C", result[1].Result.SubClass.Property3);
}
public List <CsvRecord> ParseCsvRecord(string csvContent)
{
TinyCsvParser.CsvParserOptions options = new TinyCsvParser.CsvParserOptions(true, ',');
TinyCsvParser.CsvReaderOptions readerOptions = new CsvReaderOptions(new[] { Environment.NewLine });
var parser = new TinyCsvParser.CsvParser <CsvRecord>(options, new CsvRecordMapping());
return(parser.ReadFromString(readerOptions, csvContent).Select(x => x.Result).ToList());
}
public List <TripModel> TripCsvMapper(string csvString)
{
CsvParserOptions csvParserOptions = new CsvParserOptions(true, ',');
var csvParser = new CsvParser <TripModel>(csvParserOptions, new TripCsvMapping());
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { "\r\n", "\r", "\n" });
var records = csvParser.ReadFromString(csvReaderOptions, csvString);
return(records.Select(x => x.Result).ToList());
}
public List <ProductCsv> Parse(string csvString)
{
var csvParserOptions = new CsvParserOptions(true, ',');
var csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
var csvParser = new CsvParser <ProductCsv>(csvParserOptions, new CsvProductMapping());
var records = csvParser.ReadFromString(csvReaderOptions, csvString);
return(records.Select(x => x.Result).ToList());
}
// public DecoderService()
// {
// }
public DecoderService(ILogger <DecoderService> logger, IMapper mapper)
{
_logger = logger;
_mapper = mapper;
CsvParserOptions csvParserOptions = new CsvParserOptions(false, '|');
CsvInputDataMapping csvMapper = new CsvInputDataMapping();
_csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
//TODO pensare se fare DI introducendo interfaccia ICSParser
_csvParser = new CsvParser <InputData>(csvParserOptions, csvMapper);
}
public static Book[] ReadBookCsv()
{
CsvParserOptions csvParserOptions = new CsvParserOptions(true, ',');
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
CsvBookMapping csvMapper = new CsvBookMapping();
CsvParser <Book> csvParser = new CsvParser <Book>(csvParserOptions, csvMapper);
// var record = csvParser.ReadFromFile("../data_source/books.csv", Encoding.UTF8).ToList();
var record = csvParser.ReadFromFile("Data/books.csv", Encoding.UTF8).ToList();
return(record.Select(x => x.Result).ToArray());
}
//Sets employees list
private void SetEmployees()
{
CsvParserOptions csvParserOptions = new CsvParserOptions(false, ',');
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
CsvEmployeesMapping csvMapper = new CsvEmployeesMapping();
CsvParser <Employees> csvParser = new CsvParser <Employees>(csvParserOptions, csvMapper);
GetEmployees = csvParser
.ReadFromString(csvReaderOptions, csvInput)
.Select(x => x.Result).ToList();
}
//Sets employees list
private void LoadEmployees()
{
CsvParserOptions csvParserOptions = new CsvParserOptions(false, ',');
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
var csvMapper = new MappingHelper();
CsvParser <Employee> csvParser = new CsvParser <Employee>(csvParserOptions, csvMapper);
_employeeList = csvParser
.ReadFromString(csvReaderOptions, csvInput)
.Select(x => x.Result).ToList();
}
private List <string> SplitDnParts(string distinguishedName)
{
CsvParserOptions csvParserOptions = new CsvParserOptions(false, ',');
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
CsvStringArrayMapping csvMapper = new CsvStringArrayMapping();
CsvParser <string[]> csvParser = new CsvParser <string[]>(csvParserOptions, csvMapper);
var values = csvParser
.ReadFromString(csvReaderOptions, distinguishedName).FirstOrDefault()?.Result;
return(values.ToList());
}
public static Parser <TEntity> Create <TEntity, TMapping>(TMapping mapping)
where TEntity : class, new()
where TMapping : CsvMapping <TEntity>
{
var options = new Options('"', '\\', ',');
var tokenizer = new RFC4180Tokenizer(options);
var parserOptions = new CsvParserOptions(true, "//", tokenizer);
var readerOptions = new CsvReaderOptions(new[] { "\r\n", "\n" });
var parser = new CsvParser <TEntity>(parserOptions, mapping);
return(new Parser <TEntity>(parser, readerOptions));
}
public void ToStringTest()
{
CsvParserOptions csvParserOptions = new CsvParserOptions(true, new[] { ';' });
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
CsvPersonMapping csvMapper = new CsvPersonMapping();
CsvParser <Person> csvParser = new CsvParser <Person>(csvParserOptions, csvMapper);
// Make sure the ToString() doesn't throw...
Assert.DoesNotThrow(() => csvParser.ToString());
// TODO Check ToString Output
}
public void NullInputTest()
{
CsvParserOptions csvParserOptions = new CsvParserOptions(true, new[] { ';' });
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
CsvPersonMapping csvMapper = new CsvPersonMapping();
CsvParser <Person> csvParser = new CsvParser <Person>(csvParserOptions, csvMapper);
Assert.Throws <ArgumentNullException>(() =>
{
var result = csvParser.Parse(null);
});
}
public static List <FinraRecord> ParseResponse(string finraResponse)
{
CsvParserOptions csvParserOptions = new CsvParserOptions(true, '|');
CsvPersonMapping mapping = new CsvPersonMapping();
CsvParser <FinraRecord> csvParser = new CsvParser <FinraRecord>(csvParserOptions, mapping);
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new string[] { "\r\n" });
var result = csvParser.ReadFromFinraString(csvReaderOptions, finraResponse, 2);
var a = result.ToList();
return(result.Select(r => r.Result).ToList());
}
public static async Task <List <T> > ReadCsv <T>(ICsvMapping <T> mapping, IBrowserFile file)
{
CsvParserOptions csvParserOptions = new CsvParserOptions(true, ',');
CsvParser <T> csvParser = new CsvParser <T>(csvParserOptions, mapping);
using var reader = new StreamReader(file.OpenReadStream());
var line = await reader.ReadToEndAsync();
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new string[] { "\r", "\n" });
var results = csvParser.ReadFromString(csvReaderOptions, line);
return(results.Select(x => x.Result).ToList());
}
public void ToStringTest()
{
var csvReaderOptions = new CsvReaderOptions(new string[] { Environment.NewLine });
Assert.DoesNotThrow(() => csvReaderOptions.ToString());
}