public static byte[] GetCsvBytes(this IEnum data, CsvConfig config = null) { using (var ms = new MemoryStream()) { data.WriteCsvTo(ms, config); return(ms.ToArray()); } }
public void CircularDependencyWithMultiplePropertiesTest() { var config = new CsvHelper.Configuration.Configuration(); var map = config.AutoMap <A>(); Assert.AreEqual(1, map.MemberMaps.Count); Assert.AreEqual(3, map.ReferenceMaps.Count); }
public CompletedApplicationScreening ParseApplicationResponse(string businessFileContent, string associatesFileContent) { CsvHelper.Configuration.Configuration config = new CsvHelper.Configuration.Configuration(); config.SanitizeForInjection = true; config.IgnoreBlankLines = true; config.TrimOptions = CsvHelper.Configuration.TrimOptions.Trim; config.ShouldSkipRecord = record => { return(record.All(string.IsNullOrEmpty)); }; // fix for unexpected spaces in header config.PrepareHeaderForMatch = (string header, int index) => header = header.Trim().ToLower(); TextReader businessTextReader = new StringReader(businessFileContent); var businessCsv = new CsvReader(businessTextReader, config); businessCsv.Configuration.RegisterClassMap <CsvBusinessImportMap>(); TextReader associatesTextReader = new StringReader(associatesFileContent); var associatesCsv = new CsvReader(associatesTextReader, config); associatesCsv.Configuration.RegisterClassMap <CsvAssociateImportMap>(); try { CsvBusinessImport businessImport = businessCsv.GetRecords <CsvBusinessImport>().ToList().First(); List <CsvAssociateImport> associatesImport = associatesCsv.GetRecords <CsvAssociateImport>().ToList(); CompletedApplicationScreening response = new CompletedApplicationScreening() { RecordIdentifier = businessImport.LcrbBusinessJobId.PadLeft(6, '0'), Result = CsvBusinessImport.TranslateStatus(businessImport.Result), Associates = new List <Associate>() }; foreach (var associate in associatesImport) { response.Associates.Add(new Associate() { SpdJobId = associate.LcrbAssociateJobId, LastName = associate.Last, FirstName = associate.First, MiddleName = associate.Middle }); } return(response); } catch (Exception e) { _logger.LogError("Error parsing worker response."); _logger.LogError("Message:"); _logger.LogError(e.Message); // return an empty list so we continue processing other files. return(new CompletedApplicationScreening()); } }
public static void WriteCsv(this IEnum data, Stream stream, CsvCfg config = null) { config = config ?? Configuration.Default; using (var sw = new StreamWriter(stream, config.Encoding)) { var csvWriter = new CsvWriter(sw, config); csvWriter.WriteRecords(data); } }
protected virtual CsvHelper.Configuration.Configuration GetConfiguration() { var configuration = new CsvHelper.Configuration.Configuration { Delimiter = Delimiter }; return(configuration); }
public static void WriteCsvTo(this IEnum data, Stream stream, CsvConfig config = null) { config = config ?? GetExcelAtDeConfig(); using (var sw = new StreamWriter(stream, config.Encoding)) { var csvWriter = new CsvWriter(sw, config); csvWriter.WriteRecords(data); } }
public static IList <T> ReadCsv <T>(this FileInfo file, CsvCfg config = null) { config = config ?? Configuration.Default; using (var fs = File.OpenRead(file.FullName)) using (var sr = new StreamReader(fs, config.Encoding)) { var csvReader = new CsvReader(sr, config); return(csvReader.GetRecords <T>().ToList()); } }
public void InitCsvHelperConfig() { cfg = new CsvHelper.Configuration.Configuration() { HasHeaderRecord = true, IgnoreBlankLines = true, HeaderValidated = null, MissingFieldFound = null, }; }
public static IList <T> ReadCsv <T>(string fileName, CsvConfig config = null) { config = config ?? GetExcelAtDeConfig(); using (var fs = File.OpenRead(fileName)) using (var sr = new StreamReader(fs, config.Encoding)) { var csvReader = new CsvReader(sr, config); return(csvReader.GetRecords <T>().ToList()); } }
public List <CompletedWorkerScreening> ParseWorkerResponse(string fileContent) { CsvHelper.Configuration.Configuration config = new CsvHelper.Configuration.Configuration(); config.SanitizeForInjection = true; config.IgnoreBlankLines = true; config.TrimOptions = CsvHelper.Configuration.TrimOptions.Trim; config.ShouldSkipRecord = record => { return(record.All(string.IsNullOrEmpty)); }; // fix for unexpected spaces in header config.PrepareHeaderForMatch = (string header, int index) => header = header.Trim().ToLower(); TextReader textReader = new StringReader(fileContent); var workerCsv = new CsvReader(textReader, config); workerCsv.Configuration.RegisterClassMap <CsvWorkerImportMap>(); try { List <CsvWorkerImport> imports = workerCsv.GetRecords <CsvWorkerImport>().ToList(); List <CompletedWorkerScreening> responses = new List <CompletedWorkerScreening>(); foreach (var import in imports) { if (import.RecordIdentifier.Substring(0, 2) == "WR") { responses.Add(new CompletedWorkerScreening() { RecordIdentifier = import.RecordIdentifier, ScreeningResult = CsvWorkerImport.TranslateStatus(import.Result) }); } else { responses.Add(new CompletedWorkerScreening() { SpdJobId = import.RecordIdentifier, ScreeningResult = CsvWorkerImport.TranslateStatus(import.Result) }); } } return(responses); } catch (Exception e) { _logger.LogError("Error parsing worker response."); _logger.LogError("Message:"); _logger.LogError(e.Message); // return an empty list so we continue processing other files. return(new List <CompletedWorkerScreening>()); } }
private static CsvHelper.Configuration.Configuration GetConfiguration() { if (CsvConfiguration == null) { CsvConfiguration = new CsvHelper.Configuration.Configuration(System.Globalization.CultureInfo.InvariantCulture) { MemberTypes = CsvHelper.Configuration.MemberTypes.Fields, }; } return(CsvConfiguration); }
public void CircularDependencyTest() { var config = new CsvHelper.Configuration.Configuration(); var map = config.AutoMap <ACircular>(); Assert.IsNotNull(map); Assert.AreEqual(1, map.MemberMaps.Count); Assert.AreEqual(1, map.ReferenceMaps.Count); Assert.AreEqual(1, map.ReferenceMaps[0].Data.Mapping.MemberMaps.Count); Assert.AreEqual(0, map.ReferenceMaps[0].Data.Mapping.ReferenceMaps.Count); }
/// <summary> /// Sauvegarde d'une liste typé dans un fichier CSV /// </summary> public void Write_CSV <T>(string _path, List <T> _myList) where T : class { CsvHelper.Configuration.Configuration CsvConfig = new CsvHelper.Configuration.Configuration { Delimiter = ";" }; using (TextWriter textwritter = new StreamWriter(_path, true, Encoding.GetEncoding(1252))) { var csv = new CsvWriter(textwritter, CsvConfig); csv.WriteRecords(_myList); } }
private IEnumerable <Vol> GetVols() { var csvConfig = new CsvHelper.Configuration.Configuration(); csvConfig.Delimiter = "|"; using (var fileReader = System.IO.File.OpenText(HttpContext.Server.MapPath(@"~/App_Data/VolData.csv"))) using (var csvReader = new CsvHelper.CsvReader(fileReader, csvConfig)) { return(csvReader.GetRecords <Vol>().ToList()); } }
private CsvReader GetCsvHelperReader(Resources.FileSize fileSize) { var config = new CsvHelper.Configuration.Configuration() { Delimiter = Resources.GetSeperator(fileSize).ToString(), BadDataFound = (data) => Debug.WriteLine($"Bad Data Found: {data}") }; var stream = new StreamReader(Resources.GetStream(fileSize)); return(new CsvReader(stream, config)); }
public void EnsureInternalsAreSetupWhenPassingWriterAndConfigTest() { using (var stream = new MemoryStream()) using (var writer = new StreamWriter(stream)) { var config = new CsvHelper.Configuration.Configuration(); using (var csv = new CsvWriter(writer, config)) { Assert.AreSame(config, csv.Configuration); } } }
public void Setup() { _csvConfig = new Configuration(); _csvConfig.RegisterClassMap <CsvHelperMappingForCustomObject>(); _fluentEngine = new DelimitedFileEngineFactory() .GetEngine(new FlatFileMappingForCustomObject()); var fixture = new Fixture(); _records = fixture.CreateMany <CustomObject>(N).ToArray(); }
public void EnsureInternalsAreSetupWhenPassingReaderAndConfigTest() { using (var stream = new MemoryStream()) using (var reader = new StreamReader(stream)) { var config = new CsvHelper.Configuration.Configuration(); using (var parser = new CsvParser(reader, config)) { Assert.AreSame(config, parser.Configuration); } } }
private static void RunOutputCSV(string destinationDir, bool v, List <string> logfiles) { // Create a csv configuration objection with a custom map to enable milliseconds in the dateTime field CsvHelper.Configuration.Configuration csvconf = new CsvHelper.Configuration.Configuration(); csvconf.RegisterClassMap(new LogLineMap()); // Determine Hostname string host; if (logfiles[0].Substring(0, 1) == "\\") { // First character of log paths is \ (Remote Hostname) host = logfiles[0].Split('\\')[2]; } else { host = System.Environment.MachineName; } if (v == false) { // Single CSV List <LogLine> loglines = new List <LogLine>(); Parallel.ForEach(logfiles, (log) => { loglines.AddRange(ParseLogFile(log, host)); }); string outfilename = destinationDir + "\\AllLogs.csv"; StreamWriter sw = new StreamWriter(outfilename); CsvWriter csv = new CsvWriter(sw, csvconf); csv.WriteRecords(loglines); sw.Close(); } else { // Multiple CSVs Parallel.ForEach(logfiles, (log) => { List <LogLine> loglines = ParseLogFile(log, host); if (loglines.Count > 0) { string[] filenamesplit = log.Split('\\'); string filename = filenamesplit[filenamesplit.Length - 1]; filename = filename.Replace(".log", ".csv"); string outfilename = destinationDir + "\\" + filename; StreamWriter sw = new StreamWriter(outfilename); CsvWriter csv = new CsvWriter(sw); csv.WriteRecords(loglines); sw.Close(); } }); } }
static List <CsvRow> LoadCsv(string inputFile) { List <CsvRow> inputCsvRows = new List <CsvRow>(); var csvConfig = new CsvHelper.Configuration.Configuration() { AllowComments = false, HasHeaderRecord = true, IgnoreBlankLines = true, IncludePrivateMembers = true, TrimOptions = CsvHelper.Configuration.TrimOptions.None, }; using (FileStream inputStream = new FileStream(inputFile, FileMode.Open, FileAccess.Read, FileShare.Read)) using (TextReader inputReader = new StreamReader(inputStream, Encoding.UTF8)) using (CsvReader csvReader = new CsvReader(inputReader, csvConfig)) { csvReader.Read(); csvReader.ReadHeader(); while (csvReader.Read()) { StreamingService service = csvReader.GetField <StreamingService>("Service"); string animeName = csvReader.GetField <string>("Anime"); string url = csvReader.GetField <string>("URL"); string malIdString = csvReader.GetField <string>("MAL ID (or n/a)"); MalId malId; // could be blank if (string.IsNullOrWhiteSpace(malIdString)) { malId = new MalId(malAnimeId: null, specified: false); } else if (malIdString.Equals("n/a", StringComparison.OrdinalIgnoreCase)) { // n/a means the stream does not correspond to a MAL anime. Maybe it's a stream of anime reviews // or maybe it's something incredibly obscure. malId = new MalId(malAnimeId: null, specified: true); } else { int malIdInt = int.Parse(malIdString); malId = new MalId(malAnimeId: malIdInt, specified: true); } CsvRow row = new CsvRow(service, animeName, url, malId); inputCsvRows.Add(row); } } return(inputCsvRows); }
/// <summary> /// Used to write to a CSV-formated stream via a <see cref="System.IO.StreamReader" /> /// </summary> /// <param name="stream">The CSV-formated stream to write to</param> /// <param name="csvConfiguration">A <see cref="CsvHelper.Configuration" /> configuration specification for how to read the csv file</param> public CsvRecordWriter(Stream stream, CsvHelper.Configuration.Configuration csvConfiguration = null) { var csvConfig = csvConfiguration ?? TextWranglerConfig.DefaultCsvConfigurationFactory(); if (stream == null || !stream.CanWrite) { throw new ArgumentNullException(nameof(stream), "Stream must be included and writable"); } // Keep a local ref to the stream reader so we can properly dispose of it on failure in creating the csv writer _streamWriter = new StreamWriter(stream); _csvWriter = new CsvWriter(_streamWriter, csvConfig); }
public override void Denormalize() { var conf = new CsvHelper.Configuration.Configuration() { HasHeaderRecord = false }; using (var streamReader = new StreamReader(Path, Encoding.GetEncoding("SHIFT_JIS"))) using (var csv = new CsvHelper.CsvReader(streamReader, conf)) { csv.Configuration.RegisterClassMap<SourceMapper>(); csv.Configuration.ReadingExceptionOccurred = ex => { // Do something instead of throwing an exception. return true; }; var source = csv.GetRecords<Source>().ToList(); DataTable products = FetchProducts(source.Select(r => r.JanCode).Distinct()); Func<Source, DataRow, Result> resultSelector = (a, b) => { return new Result() { DeliveredAt = a.DeliveredAt, SupplyChainManagementCode = a.SupplyChainManagementCode, SupplierCode = b["supplier_code"].ToString(), VarietyCode = a.VarietyCode, ModelNo = b["model_no"].ToString(), ProductName = b["product_name"].ToString(), JanCode = a.JanCode, StoreCode = a.StoreCode, StoreName = a.StoreName, Qty = a.Qty, UnitCost = a.UnitCost, Cost = a.Cost, UnitPrice = a.UnitPrice, Price = a.Price, }; }; var cmp = EqualityComparer<string>.Default; var alookup = source.ToLookup((x) => x.JanCode, cmp); var blookup = products.AsEnumerable().ToLookup((x) => x["jan"].ToString(), cmp); var keys = new HashSet<string>(alookup.Select(p => p.Key), cmp); var query = from key in keys from xa in alookup[key].DefaultIfEmpty(null) from xb in blookup[key].DefaultIfEmpty(null) select resultSelector(xa, xb); DenormalizedSchema_ = query.ToList(); } }
public List <DTO.DataDTO> LoadFile(string path) { StreamReader reader = new StreamReader(path, Encoding.Default); var config = new CsvHelper.Configuration.Configuration { HasHeaderRecord = false, Delimiter = ";" }; using (CsvReader csvReader = new CsvReader(reader, config, true)) { return(csvReader.GetRecords <DTO.DataDTO>().ToList()); } }
public CsvHelper.Configuration.Configuration ConvertConfiguration() { // See https://joshclose.github.io/CsvHelper/configuration var configuration = new CsvHelper.Configuration.Configuration { SanitizeForInjection = true, HasHeaderRecord = Configuration.HasHeaders, Delimiter = Configuration.Delimiter, Quote = Configuration.Quote, Comment = Configuration.Comment, }; return(configuration); }
} // end sub /// <summary> /// <para xml:lang="en">Output the names of properties of a object as header of a TSV file.</para> /// <para xml:lang="ja">TSVファイルヘッダとして、オブジェクトのプロパティの名前を出力します。</para> /// </summary> /// <typeparam name="T"> /// <para xml:lang="en">The type of object to dump.</para> /// <para xml:lang="ja">ダンプするオブジェクトの型</para> /// </typeparam> /// <param name="target"> /// <para xml:lang="en"> /// The object whose properties names are read. However, those properties values are not outputted. /// Use DumpTsvRecord method, DumpTsv method or other methods to output values. /// </para> /// <para xml:lang="ja"> /// プロパティの名前を読み取るオブジェクト。ただしプロパティの値は出力されません。 /// 値を出力するには DumpTsvRecord メソッドやDumpTsvメソッドなどを使用します。 /// </para> /// </param> /// <param name="name"> /// <para xml:lang="en">The name which is used for a file.</para> /// <para xml:lang="ja">ファイルに使用される名前。</para> /// </param> /// <param name="format"> /// <para xml:lang="en"> /// The lambda expression which is used for choosing properties to dump. /// Set like <code>a=>new {a.A, a.B}</code> to dump A property and B property of the object. /// Set like <code>a=>a</code> to dump all properties of the object. /// </para> /// <para xml:lang="ja"> /// ダンプするプロパティを選択するラムダ式。 /// オブジェクトのAプロパティとBプロパティをダンプする場合には、<code>a=>new {a.A, a.B}</code> のように指定します。 /// 全てのプロパティをダンプする場合には<code>a=>a</code>を指定します。 /// </para> /// </param> public static void DumpTsvHeader <T>(T target, string name, Func <T, object> format) { Dumper.WriteTextFile(name, ".tsv", writer => { var configuration = new CsvHelper.Configuration.Configuration { Delimiter = "\t" }; using (var tsv = new CsvHelper.CsvWriter(writer, configuration)) { var v = format(target); tsv.WriteHeader(v.GetType()); tsv.NextRecord(); } // end using (tsv) }); } // end sub
public static void WriteToCSV(this MathNet.Numerics.LinearAlgebra.Vector <double> vec, string path) { CsvHelper.Configuration.Configuration cfg = new CsvHelper.Configuration.Configuration(CultureInfo.InvariantCulture); using (StreamWriter sw = new StreamWriter(path)) using (CsvWriter cw = new CsvWriter(sw, cfg)) { for (int e = 0; e < vec.Count; e++) { cw.WriteField(e); cw.WriteField(vec[e]); cw.NextRecord(); } } }
public void DelimiterReaderWithConfigurationTest() { var configuration = new CsvHelper.Configuration.Configuration { Delimiter = ":" }; using (var reader = new StringReader("Id§Name\r\n1§one\r\n")) using (var csv = new CsvReader(reader, configuration)) { var records = csv.GetRecords <DelimiterTestClass>().ToList(); var actual = csv.Configuration.Delimiter; Assert.AreEqual("§", actual); } }
public async Task <IActionResult> UploadWS(IFormFile file, string LoginId, string SessionKey) { var(result, userStatus) = IsInvalidSession(LoginId, SessionKey); if (!result) { return(View("~/Views/Users/Login.cshtml")); } if (file.Length < 1) { return(View("upload", userStatus)); } try { var config = new CsvHelper.Configuration.Configuration { HasHeaderRecord = false, MissingFieldFound = null, IgnoreBlankLines = true, }; using (var streamReader = new StreamReader(file.OpenReadStream())) using (var csv = new CsvReader(streamReader, config)) { IEnumerable <WSCsvRow> wsCsvRow = csv.GetRecords <WSCsvRow>(); List <WorkScheduleMaster> wsmList; if (csvValidationWsErr(wsCsvRow, out wsmList)) { return(View("upload", userStatus)); } await _wsmService.UploadAsync(wsmList); ViewBag.Message = String.Format(ApiConstant.INFO_UPLOAD_WS_01, wsmList.Count); } } catch (Exception) { ViewBag.Message = String.Format(ApiConstant.ERR90); } return(View("upload", userStatus)); }
private static List<dynamic> GetRecords( string filePath ) { if ( File.Exists( filePath ) ) { using ( var s = File.OpenText( filePath ) ) { var config = new CsvHelper.Configuration.Configuration(); config.BadDataFound = null; var reader = new CsvReader( s, config ); reader.Configuration.HasHeaderRecord = true; var records = reader.GetRecords<dynamic>().ToList(); return records; } } return null; }
static void Main(string[] args) { CommandLineArgs commandLine = new CommandLineArgs(args); List <mal_anime_prerequisite> prereqs = new List <mal_anime_prerequisite>(); // open input file and parse it var csvConfig = new CsvHelper.Configuration.Configuration() { AllowComments = false, HasHeaderRecord = true, IgnoreBlankLines = true, IncludePrivateMembers = true, TrimOptions = CsvHelper.Configuration.TrimOptions.None, }; using (FileStream inputStream = new FileStream(commandLine.InputFilePath, FileMode.Open, FileAccess.Read, FileShare.Read)) using (TextReader inputReader = new StreamReader(inputStream, Encoding.UTF8)) using (CsvReader csvReader = new CsvReader(inputReader, csvConfig)) { while (csvReader.Read()) { string prereqMalUrl = csvReader.GetField <string>("Prerequisite"); string animeMalUrl = csvReader.GetField <string>("Anime"); int prereqId = GetMalIdFromMalUrl(prereqMalUrl); int animeId = GetMalIdFromMalUrl(animeMalUrl); mal_anime_prerequisite prereq = new mal_anime_prerequisite( _mal_anime_id: animeId, _prerequisite_mal_anime_id: prereqId ); prereqs.Add(prereq); } } string sql = mal_anime_prerequisite.CreateRefreshPrerequisiteMapSql(prereqs); using (FileStream outputStream = new FileStream(commandLine.OutputFilePath, FileMode.Create, FileAccess.Write, FileShare.Read)) using (StreamWriter output = new StreamWriter(outputStream, Encoding.UTF8)) { output.Write(sql); } }