public void AddGetRemoveTest() { var config = new CsvHelper.Configuration.Configuration(); var customOptions = new TypeConverterOptions { Formats = new string[] { "custom" }, }; config.TypeConverterOptionsCache.AddOptions <string>(customOptions); var options = config.TypeConverterOptionsCache.GetOptions <string>(); Assert.AreEqual(customOptions.Formats, options.Formats); config.TypeConverterOptionsCache.RemoveOptions <string>(); options = config.TypeConverterOptionsCache.GetOptions <string>(); Assert.AreNotEqual(customOptions.Formats, options.Formats); }
/// <inheritdoc/> public virtual void WriteField <T>(T field, ITypeConverter converter) { var type = field == null ? typeof(string) : field.GetType(); reusableMemberMapData.TypeConverter = converter; if (!typeConverterOptionsCache.TryGetValue(type, out TypeConverterOptions typeConverterOptions)) { typeConverterOptions = TypeConverterOptions.Merge(new TypeConverterOptions { CultureInfo = cultureInfo }, context.TypeConverterOptionsCache.GetOptions(type)); typeConverterOptionsCache.Add(type, typeConverterOptions); } reusableMemberMapData.TypeConverterOptions = typeConverterOptions; var fieldString = converter.ConvertToString(field, this, reusableMemberMapData); WriteConvertedField(fieldString, type); }
public void GetRecordsTest() { using (var stream = new MemoryStream()) using (var reader = new StreamReader(stream)) using (var writer = new StreamWriter(stream)) using (var csvReader = new CsvReader(reader)) { writer.WriteLine("\"1,234\",\"5,678\""); writer.Flush(); stream.Position = 0; var options = new TypeConverterOptions { NumberStyle = NumberStyles.AllowThousands }; csvReader.Configuration.TypeConverterOptionsCache.AddOptions <int>(options); csvReader.Configuration.HasHeaderRecord = false; csvReader.GetRecords <Test>().ToList(); } }
public void AddGetRemoveTest() { var customOptions = new TypeConverterOptions { Formats = new string[] { "custom" }, }; var typeConverterOptionsFactory = new TypeConverterOptionsCache(); typeConverterOptionsFactory.AddOptions <string>(customOptions); var options = typeConverterOptionsFactory.GetOptions <string>(); Assert.AreEqual(customOptions.Formats, options.Formats); typeConverterOptionsFactory.RemoveOptions <string>(); options = typeConverterOptionsFactory.GetOptions <string>(); Assert.AreNotEqual(customOptions.Formats, options.Formats); }
public void ConvertFromStringTest() { var converter = new BooleanConverter(); var typeConverterOptions = new TypeConverterOptions { CultureInfo = CultureInfo.CurrentCulture }; Assert.IsTrue((bool)converter.ConvertFromString(typeConverterOptions, "true")); Assert.IsTrue((bool)converter.ConvertFromString(typeConverterOptions, "True")); Assert.IsTrue((bool)converter.ConvertFromString(typeConverterOptions, "TRUE")); Assert.IsTrue((bool)converter.ConvertFromString(typeConverterOptions, "1")); Assert.IsTrue((bool)converter.ConvertFromString(typeConverterOptions, "yes")); Assert.IsTrue((bool)converter.ConvertFromString(typeConverterOptions, "YES")); Assert.IsTrue((bool)converter.ConvertFromString(typeConverterOptions, "y")); Assert.IsTrue((bool)converter.ConvertFromString(typeConverterOptions, "Y")); Assert.IsTrue((bool)converter.ConvertFromString(typeConverterOptions, " true ")); Assert.IsTrue((bool)converter.ConvertFromString(typeConverterOptions, " yes ")); Assert.IsTrue((bool)converter.ConvertFromString(typeConverterOptions, " y ")); Assert.IsFalse((bool)converter.ConvertFromString(typeConverterOptions, "false")); Assert.IsFalse((bool)converter.ConvertFromString(typeConverterOptions, "False")); Assert.IsFalse((bool)converter.ConvertFromString(typeConverterOptions, "FALSE")); Assert.IsFalse((bool)converter.ConvertFromString(typeConverterOptions, "0")); Assert.IsFalse((bool)converter.ConvertFromString(typeConverterOptions, "no")); Assert.IsFalse((bool)converter.ConvertFromString(typeConverterOptions, "NO")); Assert.IsFalse((bool)converter.ConvertFromString(typeConverterOptions, "n")); Assert.IsFalse((bool)converter.ConvertFromString(typeConverterOptions, "N")); Assert.IsFalse((bool)converter.ConvertFromString(typeConverterOptions, " false ")); Assert.IsFalse((bool)converter.ConvertFromString(typeConverterOptions, " 0 ")); Assert.IsFalse((bool)converter.ConvertFromString(typeConverterOptions, " no ")); Assert.IsFalse((bool)converter.ConvertFromString(typeConverterOptions, " n ")); try { converter.ConvertFromString(typeConverterOptions, null); Assert.Fail(); } catch (CsvTypeConverterException) { } }
public void WriteFieldTest() { using (var stream = new MemoryStream()) using (var reader = new StreamReader(stream)) using (var writer = new StreamWriter(stream)) using (var csvWriter = new CsvWriter(writer)) { var options = new TypeConverterOptions { Format = "c" }; csvWriter.Configuration.TypeConverterOptionsFactory.AddOptions <int>(options); csvWriter.WriteField(1234); csvWriter.NextRecord(); writer.Flush(); stream.Position = 0; var record = reader.ReadToEnd(); Assert.AreEqual("\"$1,234.00\"\r\n", record); } }
public byte[] GetTemplate <T, TMap>(string delimiter = ";", string newLine = "\n", bool hasHeaderRecord = false) where TMap : ClassMap <T> where T : class, new() { using var fileStream = new MemoryStream(); using var writer = new StreamWriter(fileStream); using var csv = new CsvWriter(writer, GetBaseConfiguration(delimiter, newLine, hasHeaderRecord)); var options = new TypeConverterOptions { Formats = new[] { "yyyy-MM-ddTHH:mm:ss:fff" } }; csv.Context.TypeConverterOptionsCache.AddOptions <DateTime>(options); csv.Context.TypeConverterOptionsCache.AddOptions <DateTime?>(options); csv.Context.RegisterClassMap <TMap>(); csv.WriteHeader <T>(); csv.NextRecord(); csv.WriteRecords(new List <T>() { }); csv.Flush(); return(fileStream.ToArray()); }
public void ConvertFromStringTest() { var converter = new CharConverter(); var typeConverterOptions = new TypeConverterOptions { CultureInfo = CultureInfo.CurrentCulture }; Assert.AreEqual('a', converter.ConvertFromString(typeConverterOptions, "a")); Assert.AreEqual('a', converter.ConvertFromString(typeConverterOptions, " a ")); try { converter.ConvertFromString(typeConverterOptions, null); Assert.Fail(); } catch (CsvTypeConverterException) { } }
public void AddGetRemoveTest() { var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture); var context = new CsvContext(config); var customOptions = new TypeConverterOptions { Formats = new string[] { "custom" }, }; context.TypeConverterOptionsCache.AddOptions <string>(customOptions); var options = context.TypeConverterOptionsCache.GetOptions <string>(); Assert.Equal(customOptions.Formats, options.Formats); context.TypeConverterOptionsCache.RemoveOptions <string>(); options = context.TypeConverterOptionsCache.GetOptions <string>(); Assert.NotEqual(customOptions.Formats, options.Formats); }
public void GetRecordsAppliedWhenMappedTest() { var options = new TypeConverterOptions { NumberStyle = NumberStyles.AllowThousands }; using (var stream = new MemoryStream()) using (var reader = new StreamReader(stream)) using (var writer = new StreamWriter(stream)) using (var csvReader = new CsvReader(reader)) { csvReader.Configuration.Delimiter = ","; writer.WriteLine("\"1,234\",\"$5,678\""); writer.Flush(); stream.Position = 0; csvReader.Configuration.TypeConverterOptionsCache.AddOptions<int>(options); csvReader.Configuration.HasHeaderRecord = false; csvReader.Configuration.RegisterClassMap<TestMap>(); csvReader.GetRecords<Test>().ToList(); } }
public override object ConvertFromString(TypeConverterOptions options, string text) { string[] vals = text.Split(' '); List <Orbital> orbitals = new List <Orbital>(); string basedOn = ""; foreach (var val in vals) { if (val.StartsWith("[")) { basedOn = val.Substring(1, val.Length - 2); continue; } var shell = byte.Parse(val.Substring(0, 1)); var type = char.Parse(val.Substring(1, 1)); var count = byte.Parse(val.Substring(2)); orbitals.Add(new Orbital(shell, type, count)); } return(new Configuration(basedOn, orbitals.ToArray())); }
public IEnumerable <Transaction> Parse(IFormFile file) { var stream = file.OpenReadStream(); using var reader = new StreamReader(stream); using var csv = new CsvReader(reader, CultureInfo.InvariantCulture); var options = new TypeConverterOptions { Formats = new [] { "dd/MM/yyyy hh:mm:ss" } }; csv.Configuration.TypeConverterOptionsCache.AddOptions <DateTime>(options); csv.Configuration.HasHeaderRecord = false; csv.Configuration.TrimOptions = TrimOptions.Trim; var records = csv.GetRecords <Transaction>(); return(records.ToList()); }
protected override object ConvertFrom(TypeConverterOptions options, string text) { DateTime time; if (text.EqualIgnoreCase("unknown")) { return(DateTime.MinValue); } if (!DateTime.TryParse(text, out time)) { return(DateTime.MinValue); } /*if (!DateTime.TryParseExact(text, "g", DateTimeFormatInfo.InvariantInfo, DateTimeStyles.None, * out time)) * { * return DateTime.MinValue; * }*/ return(time); }
public void ProcessFile(string filename) { DataList.Clear(); using var fileReader = File.OpenText(filename); var csv = new CsvReader(fileReader, CultureInfo.InvariantCulture); var o = new TypeConverterOptions { DateTimeStyle = DateTimeStyles.AssumeUniversal & DateTimeStyles.AdjustToUniversal }; csv.Context.TypeConverterOptionsCache.AddOptions <KapeCopyLogData>(o); var foo = csv.Context.AutoMap <KapeCopyLogData>(); foo.Map(t => t.Line).Ignore(); foo.Map(t => t.Tag).Ignore(); csv.Context.RegisterClassMap(foo); var records = csv.GetRecords <KapeCopyLogData>(); var ln = 1; foreach (var record in records) { Log.Debug("Line # {Line}, Record: {RawRecord}", ln, csv.Context.Parser.RawRecord); record.Line = ln; record.Tag = TaggedLines.Contains(ln); DataList.Add(record); ln += 1; } }
private static async Task <LocationInfo> GetInfo(TraceWriter log, BeaconData beacon, ExecutionContext context) { LogHelper.Log(log, $"GetBeaconIdentifier called: {beacon.Identifier}"); if (string.IsNullOrEmpty(beacon.Identifier)) { return(null); } var path = $"{context.FunctionAppDirectory}\\beacons.csv"; using (TextReader reader = File.OpenText(path)) { var configuration = new Configuration { HasHeaderRecord = true, }; var doubleConverterOptions = new TypeConverterOptions { CultureInfo = CultureInfo.InvariantCulture }; var csv = new CsvReader(reader, configuration); csv.Configuration.TypeConverterOptionsCache.AddOptions <double>(doubleConverterOptions); await csv.ReadAsync(); // skip first header line while (await csv.ReadAsync()) { var name = csv.GetField <string>(0); if (!string.IsNullOrEmpty(name) && name.Equals(beacon.Identifier, StringComparison.InvariantCultureIgnoreCase)) { return(new LocationInfo { Name = csv.GetField <string>(1), Coordinates = new GeoCoordinates(csv.GetField <double>(4), csv.GetField <double>(5)), Beacon = beacon }); } } } return(null); }
/// <summary> /// Creates a <see cref="Delegate"/> of type <see cref="Func{T}"/> /// that will create a record of the given type using the current /// reader row. /// </summary> /// <param name="recordType">The record type.</param> protected override Delegate CreateCreateRecordDelegate(Type recordType) { var method = typeof(IReaderRow).GetProperty("Item", typeof(string), new[] { typeof(int) }).GetGetMethod(); Expression fieldExpression = Expression.Call(Expression.Constant(Reader), method, Expression.Constant(0, typeof(int))); var memberMapData = new MemberMapData(null) { Index = 0, TypeConverter = Reader.Configuration.TypeConverterFactory.GetConverter(recordType) }; memberMapData.TypeConverterOptions = TypeConverterOptions.Merge(new TypeConverterOptions(), Reader.context.ReaderConfiguration.TypeConverterOptionsFactory.GetOptions(recordType)); memberMapData.TypeConverterOptions.CultureInfo = Reader.context.ReaderConfiguration.CultureInfo; fieldExpression = Expression.Call(Expression.Constant(memberMapData.TypeConverter), "ConvertFromString", null, fieldExpression, Expression.Constant(Reader), Expression.Constant(memberMapData)); fieldExpression = Expression.Convert(fieldExpression, recordType); var funcType = typeof(Func <>).MakeGenericType(recordType); return(Expression.Lambda(funcType, fieldExpression).Compile()); }
public override string ConvertToString(TypeConverterOptions options, object value) { var list = (List <BoxTrackingCode>)value; if (list == null) { list = new List <BoxTrackingCode>(); } var trackingCodeStrings = new StringBuilder(); for (var i = 0; i < list.Count; i++) { var trackingCode = list[i]; trackingCodeStrings.Append($"name:{trackingCode.Name},value:{trackingCode.Value}"); if (i != list.Count - 1) { trackingCodeStrings.Append(Environment.NewLine); } } return(trackingCodeStrings.ToString()); }
public object ConvertFromString(TypeConverterOptions options, string text) { DateTime result; if (text.Contains("/") && DateTime.TryParse(text, new CultureInfo("en-US"), DateTimeStyles.None, out result)) { return(result); } if (DateTime.TryParse(text, new CultureInfo("de-DE"), DateTimeStyles.None, out result)) { return(result); } if (DateTime.TryParse(text, CultureInfo.InvariantCulture, DateTimeStyles.None, out result)) { return(result); } throw new Exception("Unable to parse date '" + text + "'."); }
public void WriteFieldTest() { using (var stream = new MemoryStream()) using (var reader = new StreamReader(stream)) using (var writer = new StreamWriter(stream)) using (var csvWriter = new CsvWriter(writer, new CultureInfo("en-US"))) { csvWriter.Configuration.Delimiter = ","; var options = new TypeConverterOptions { Formats = new string[] { "c" } }; csvWriter.Configuration.TypeConverterOptionsCache.AddOptions <int>(options); csvWriter.WriteField(1234); csvWriter.NextRecord(); writer.Flush(); stream.Position = 0; var record = reader.ReadToEnd(); Assert.AreEqual("\"$1,234.00\"\r\n", record); } }
private static List <Movie> GetMovies(string fileName) { List <Movie> returnValue = new List <Movie>(); if (File.Exists(fileName)) { using (var reader = new StreamReader(fileName)) { using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture)) { csv.Configuration.Delimiter = ","; var options = new TypeConverterOptions { Formats = new[] { "yyyy-MM-dd" } }; csv.Configuration.TypeConverterOptionsCache.AddOptions <DateTime>(options); returnValue = csv.GetRecords <Movie>().ToList(); } } } return(returnValue); }
public override string ConvertToString(TypeConverterOptions options, object value) { var location = value as CsvJobLocation; if (location == null) { return(string.Empty); } var result = // ReSharper disable once UseStringInterpolation string.Format("{0} {1} {2} {3} {4} {5}", location.Street, location.HouseNumber, string.IsNullOrEmpty(location.FloorLevel) ? string.Empty : "(Stockwerk: " + location.FloorLevel + ")", location.ZipCode, location.City, string.IsNullOrEmpty(location.AdditionalDescription) ? string.Empty : "Zusatzbeschreibung: " + location.AdditionalDescription); return(result); }
public void ConvertFromExcelTest() { var converter = new Int16Converter(); var typeConverterOptions = new TypeConverterOptions { CultureInfo = CultureInfo.CurrentCulture }; Assert.AreEqual((short)123, converter.ConvertFromExcel(typeConverterOptions, (double)123)); Assert.AreEqual((short)123, converter.ConvertFromExcel(typeConverterOptions, "123")); Assert.AreEqual((short)123, converter.ConvertFromExcel(typeConverterOptions, " 123 ")); Assert.AreEqual((short)0, converter.ConvertFromExcel(typeConverterOptions, null)); typeConverterOptions.NumberStyle = NumberStyles.HexNumber; Assert.AreEqual((short)0x123, converter.ConvertFromExcel(typeConverterOptions, "123")); try { converter.ConvertFromExcel(typeConverterOptions, ""); Assert.Fail(); } catch (ExcelTypeConverterException) { } }
public void GetFieldTest() { using (var stream = new MemoryStream()) using (var reader = new StreamReader(stream)) using (var writer = new StreamWriter(stream)) using (var csvReader = new CsvReader(reader)) { writer.WriteLine("\"1,234\",\"5,678\""); writer.Flush(); stream.Position = 0; var options = new TypeConverterOptions { NumberStyle = NumberStyles.AllowThousands }; csvReader.Configuration.TypeConverterOptionsFactory.AddOptions <int>(options); csvReader.Configuration.HasHeaderRecord = false; csvReader.Read(); Assert.AreEqual(1234, csvReader.GetField <int>(0)); Assert.AreEqual(5678, csvReader.GetField(typeof(int), 1)); } }
private void btnDownload_Click(object sender, EventArgs e) { try { if (string.IsNullOrEmpty(_selectedCsvFileName)) { MessageBox.Show("Please select file"); return; } var button = (Button)sender; button.Visible = false; ClearTextInput(); SetLoading(true); var fileName = $"{Guid.NewGuid()}.csv"; using var fileStream = File.Create(fileName); using var streamReader = new StreamReader(_selectedCsvFileName); using var streamWriter = new StreamWriter(fileStream) { AutoFlush = true }; using var csvWriter = new CsvWriter(streamWriter); using var csvReader = new CsvReader(streamReader); var options = new TypeConverterOptions { Formats = new[] { "MM/dd/yyyy hh:mm" } }; csvWriter.Configuration.TypeConverterOptionsCache.AddOptions <DateTime>(options); WriteHeader(csvWriter); WriteContents(csvReader, csvWriter); SetLoading(false); OpenCreatedFile(fileName); _selectedCsvFileName = string.Empty; button.Visible = true; } catch (Exception exception) { MessageBox.Show(exception.Message); SetLoading(false); ClearTextInput(); } }
public object ConvertFromString(TypeConverterOptions options, string text) { if (string.IsNullOrWhiteSpace(text)) { return(null); } var items = text.Split( new[] { InnerFieldDelimiter, InnerItemDelimiter }, StringSplitOptions.RemoveEmptyEntries); var result = new HashSet <Point>(); for (int i = 0; i < items.Length; i += 2) { var a = int.Parse(items[i], options.NumberStyle.GetValueOrDefault()); var b = int.Parse(items[i + 1], options.NumberStyle.GetValueOrDefault()); result.Add(new Point(a, b)); } return(result); }
public void ConvertFromExcelTest() { var converter = new EnumConverter(typeof(TestEnum)); var typeConverterOptions = new TypeConverterOptions { CultureInfo = CultureInfo.CurrentCulture }; Assert.AreEqual(TestEnum.One, converter.ConvertFromExcel(typeConverterOptions, "One")); Assert.AreEqual(TestEnum.One, converter.ConvertFromExcel(typeConverterOptions, "one")); Assert.AreEqual(TestEnum.One, converter.ConvertFromExcel(typeConverterOptions, "1")); try { Assert.AreEqual(TestEnum.One, converter.ConvertFromExcel(typeConverterOptions, "")); Assert.Fail(); } catch (ExcelTypeConverterException) { } try { Assert.AreEqual(TestEnum.One, converter.ConvertFromExcel(typeConverterOptions, null)); Assert.Fail(); } catch (ExcelTypeConverterException) { } }
/// <summary> /// Writes the field to the CSV file. /// When all fields are written for a record, /// <see cref="IWriter.NextRecord" /> must be called /// to complete writing of the current record. /// </summary> /// <typeparam name="T">The type of the field.</typeparam> /// <param name="field">The field to write.</param> /// <param name="converter">The converter used to convert the field into a string.</param> public virtual void WriteField <T>(T field, ITypeConverter converter) { var type = field == null ? typeof(string) : field.GetType(); context.ReusableMemberMapData.TypeConverter = converter; //if( !context.TypeConverterOptionsCache.TryGetValue( type, out TypeConverterOptions typeConverterOptions ) ) TypeConverterOptions typeConverterOptions = CSharp6Extension.TryGetValue <Type, TypeConverterOptions>(context.TypeConverterOptionsCache, type); if (typeConverterOptions == default(TypeConverterOptions)) { typeConverterOptions = TypeConverterOptions.Merge(new TypeConverterOptions { CultureInfo = context.WriterConfiguration.CultureInfo }, context.WriterConfiguration.TypeConverterOptionsCache.GetOptions(type)); context.TypeConverterOptionsCache.Add(type, typeConverterOptions); } context.ReusableMemberMapData.TypeConverterOptions = typeConverterOptions; var fieldString = converter.ConvertToString(field, this, context.ReusableMemberMapData); WriteConvertedField(fieldString); }
public override string ConvertToString(TypeConverterOptions options, object value) { var personsCollection = value as IEnumerable <CsvPerson>; var singlePerson = value as CsvPerson; var result = string.Empty; // If the object is a list of persons, save full person list of persons if (personsCollection != null) { result = personsCollection.Aggregate(string.Empty, (current, person) => current + $"({person.Prename} {person.Surname}) "); } // if it's just a single person, save this person if (singlePerson != null) { result = $"{singlePerson.Prename} {singlePerson.Surname}"; } return(result); }
public void ConvertFromExcelTest() { var converter = new TimeSpanConverter(); var typeConverterOptions = new TypeConverterOptions { CultureInfo = CultureInfo.CurrentCulture }; var dateTime = DateTime.Now; var timeSpan = new TimeSpan(dateTime.Hour, dateTime.Minute, dateTime.Second, dateTime.Millisecond); var timeString = timeSpan.ToString(); // Valid conversions. Assert.AreEqual(timeString, converter.ConvertFromExcel(typeConverterOptions, timeSpan.ToString()).ToString()); Assert.AreEqual(timeString, converter.ConvertFromExcel(typeConverterOptions, " " + timeSpan + " ").ToString()); // Invalid conversions. try { converter.ConvertFromExcel(typeConverterOptions, null); Assert.Fail(); } catch (ExcelTypeConverterException) { } }
public void ComponentModelCompatibilityTest() { var converter = new TimeSpanConverter(); var cmConverter = new System.ComponentModel.TimeSpanConverter(); var typeConverterOptions = new TypeConverterOptions { CultureInfo = CultureInfo.CurrentCulture }; try { cmConverter.ConvertFromString(""); Assert.Fail(); } catch (FormatException) {} try { var val = (DateTime)converter.ConvertFromString(typeConverterOptions, ""); Assert.Fail(); } catch (CsvTypeConverterException) {} try { cmConverter.ConvertFromString(null); Assert.Fail(); } catch (NotSupportedException) { } try { converter.ConvertFromString(typeConverterOptions, null); Assert.Fail(); } catch (CsvTypeConverterException) { } }