public async Task<IEnumerable<ChimetDataRecord>> DownloadData(DateTime day)
{
WebRequest dateRequest = HttpWebRequest.Create(string.Format("http://{1}/archive/{0:yyyy}/{0:MMMM}/CSV/{2}{0:ddMMMyyyy}.csv", day, this.Station.Address, this.Station.ShortName));
WebResponse data = await dateRequest.GetResponseAsync().ConfigureAwait(false);
CsvHelper.Configuration.CsvConfiguration config = new CsvHelper.Configuration.CsvConfiguration();
config.RegisterClassMap<ChimetDataRecordMap>();
using (var reader = new CsvHelper.CsvReader(new System.IO.StreamReader(data.GetResponseStream()), config))
{
return reader.GetRecords<ChimetDataRecord>().ToList().AsReadOnly();
}
}
private static IEnumerable <string[]> ReadInternal(System.IO.Stream stream)
{
using (var reader = new System.IO.StreamReader(stream))
{
var configuration = new CSV.Configuration.CsvConfiguration(CultureInfo.CurrentCulture)
{
Delimiter = CultureInfo.CurrentCulture.TextInfo.ListSeparator,
CultureInfo = CultureInfo.CurrentCulture,
AllowComments = true,
Comment = '#'
};
using (var parser = new CSV.CsvParser(reader, configuration))
{
while (true)
{
var fields = parser.Read();
if (fields == null)
{
break;
}
yield return(fields);
}
}
}
}
private void SaveRecordsToCSV(List <ScRecord> records, string dName)
{
if (!records.Any())
{
return;
}
var fileName = Path.Combine(folderBrowserDialog1.SelectedPath, $"{dName}-{_loadNumber}.uso");
if (File.Exists(fileName))
{
File.Delete(fileName);
}
for (short i = 1; i <= records.Count; ++i)
{
records[i - 1].RowNum = i;
records[i - 1].Height = decimal.Parse(tableLayoutPanel1.Controls.OfType <RadioButton>().FirstOrDefault(r => r.Checked).Text);
}
using (var writer = new StreamWriter(fileName, true, Encoding.UTF8))
{
writer.WriteLine($"{dName} samples changer list - download {_loadNumber}");
writer.WriteLine("LLI");
writer.WriteLine("№\tSample set\tSamp.\tw., gr\th., sm\tIrr. beg. date\tIrr. beg. time\tIrr. fin. date\tIrr. fin. time");
var csvopt = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
csvopt.HasHeaderRecord = false;
csvopt.Delimiter = "\t";
using (var csv = new CsvWriter(writer, csvopt))
{
csv.WriteRecords(records);
}
}
}
static void Main(string[] args)
{
CultureInfo.CurrentCulture = new CultureInfo("en-US");
var csvConfiguration = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.CurrentCulture)
{
Delimiter = ",",
PrepareHeaderForMatch = (s, i) => s.TrimStart().TrimEnd(),
HasHeaderRecord = true,
SanitizeForInjection = true,
MissingFieldFound = null
};
var manifestConfiguration = new ManifestConfiguration
{
Format = "{delimiter}{resource}{delimiter}{extension}",
Delimiter = ".",
Extension = "csv",
ExtensionFieldName = "{extension}",
ResourceFieldName = "{resource}",
DelimiterFieldName = "{delimiter}"
};
SeederConfiguration.ResetConfiguration(csvConfiguration, manifestConfiguration, assembly: typeof(Program).GetTypeInfo().Assembly);
using (var context = new ProductsDbContext())
{
//context.Products.SeedDbSetIfEmpty(nameof(context.Products));
context.Suppliers.SeedFromResource(nameof(context.Suppliers));
context.SaveChanges();
}
}
public void Run(IEnumerable<Company> organisations, string filePath)
{
var conf = new CsvHelper.Configuration.CsvConfiguration();
conf.UseInvariantCulture = true;
var sb = new StringBuilder();
using (var streamWriter = new StringWriter(sb))
using (var writer = new CsvWriter(streamWriter, conf))
{
writer.WriteField("Name");
writer.WriteField("Email");
writer.WriteField("Location");
writer.WriteField("Size");
writer.WriteField("Industry");
writer.WriteField("Url");
writer.WriteField("Bilanz2011");
writer.WriteField("Bilanz2012");
writer.NextRecord();
foreach (var orga in organisations)
{
writer.WriteField(orga.Name);
writer.WriteField(orga.Email);
writer.WriteField(orga.Location);
writer.WriteField(orga.Size);
writer.WriteField(orga.Industry);
writer.WriteField(orga.Url);
writer.WriteField(orga.WelfareBalanceFor2011);
writer.WriteField(orga.WelfareBalanceFor2012);
writer.NextRecord();
}
File.WriteAllText(filePath, sb.ToString(), Encoding.Default);
}
}
public IEnumerable <string> CsvColumnNames()
{
var conf = new CsvHelper.Configuration.CsvConfiguration();
this.SetMapping(conf);
return(conf.Properties.Select(f => f.NameValue));
}
/// <summary>
/// Write database records to text based file format.
/// </summary>
/// <param name="path">The fields file path.</param>
/// <param name="fs">The file system.</param>
/// <param name="database">The source records database.</param>
void ITextFieldWriter <XDatabase> .Write(string path, IFileSystem fs, XDatabase database)
{
using (var writer = new System.IO.StringWriter())
{
var configuration = new CSV.Configuration.CsvConfiguration();
configuration.Delimiter = CultureInfo.CurrentCulture.TextInfo.ListSeparator;
configuration.CultureInfo = CultureInfo.CurrentCulture;
using (var csv = new CSV.CsvWriter(writer, configuration))
{
// columns
csv.WriteField(database.IdColumnName);
foreach (var column in database.Columns)
{
csv.WriteField(column.Name);
}
csv.NextRecord();
// records
foreach (var record in database.Records)
{
csv.WriteField(record.Id.ToString());
foreach (var value in record.Values)
{
csv.WriteField(value.Content);
}
csv.NextRecord();
}
}
fs.WriteUtf8Text(path, writer.ToString());
}
}
public void EndBufferTest()
{
var config = new CsvHelper.Configuration.CsvConfiguration
{
BufferSize = 12
};
using (var stream = new MemoryStream())
using (var writer = new StreamWriter(stream))
using (var reader = new StreamReader(stream))
using (var parser = new CsvParser(reader, config))
{
writer.Write("111,222,333\r\naaa,bbb,ccc\r\n");
writer.Flush();
stream.Position = 0;
// BufferSize is set to 12 to force a buffer read after the first \r
var row = parser.Read();
Assert.IsNotNull(row);
Assert.AreEqual("111", row[0]);
Assert.AreEqual("222", row[1]);
Assert.AreEqual("333", row[2]);
row = parser.Read();
Assert.IsNotNull(row);
Assert.AreEqual("aaa", row[0]);
Assert.AreEqual("bbb", row[1]);
Assert.AreEqual("ccc", row[2]);
}
}
static void Main(string[] args)
{
// Создание генератора случайных чисел
Random rand = new Random();
// Путь к файлу numbers.csv
string path = "C:/numbers.csv";
// Создание потока ввода в файл
using (StreamWriter streamWrite = new StreamWriter(path))
{
// Настраиваем разделитель csv файла
var config = new CsvHelper.Configuration.CsvConfiguration(System.Globalization.CultureInfo.CurrentCulture)
{
Delimiter = ","
};
// Создание потока записи csv файла на основе потока ввода в файл
using (CsvWriter csvWrite = new CsvWriter(streamWrite, config))
{
// Цикл добавления столбцов
for (int i = 0; i < 100; i++)
{
// Добавление числа в файл numbers.csv
csvWrite.WriteField(rand.Next(1, 100).ToString());
}
}
}
}
public void CommentThatCrossesBuffersShouldNotAddToFieldTest()
{
var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture)
{
AllowComments = true,
BufferSize = 10
};
using (var stream = new MemoryStream())
using (var reader = new StreamReader(stream))
using (var writer = new StreamWriter(stream))
using (var parser = new CsvParser(reader, config))
{
parser.Configuration.Delimiter = ",";
writer.Write("1,2\r\n");
writer.Write("#commented line\r\n");
writer.Write("3,4");
writer.Flush();
stream.Position = 0;
parser.Read();
var line = parser.Read();
Assert.AreEqual("3", line[0]);
Assert.AreEqual("4", line[1]);
}
}
public static IEnumerable <string> GetCsvFileHeaders <TMap>() where TMap : CsvHelper.Configuration.CsvClassMap
{
var conf = new CsvHelper.Configuration.CsvConfiguration();
conf.ClassMapping <TMap>();
return(conf.Properties.Select(f => f.NameValue));
}
/// <summary>
/// Read Alice's Inventory CSV to pull things not available from Finerworks API, like handleId, description, material, and size
/// </summary>
/// <returns></returns>
public static List <AliceInventoryRowModel> ReadCsv()
{
var results = new List <AliceInventoryRowModel>();
var CsvFactory = new CsvHelper.Factory();
var configuration = new CsvHelper.Configuration.CsvConfiguration(System.Globalization.CultureInfo.CurrentCulture);
// Configure CSV reader
configuration.DetectColumnCountChanges = true;
configuration.HasHeaderRecord = true;
configuration.IgnoreBlankLines = true;
configuration.TrimOptions = CsvHelper.Configuration.TrimOptions.Trim;
configuration.Delimiter = ",";
// Map properties of RegisterBulkCsvRowModel to field headers in CSV file
configuration.RegisterClassMap <AliceInventoryCsvRowMap>();
using (var txtreader = new StreamReader("Inventory3.csv"))
{
using (var csv = CsvFactory.CreateReader(txtreader, configuration))
{
// For each row in CSV file
results.AddRange(csv.GetRecords <AliceInventoryRowModel>());
}
txtreader.Close();
}
return(results);
}
public DataSet ReadOrderFile(FileInfo file, CsvReaderConfiguration config)
{
var csvHelperConfig = new CsvHelper.Configuration.CsvConfiguration {
SkipEmptyRecords = config.SkipEmptyRecords, ThrowOnBadData = true
};
var result = DataTableCreator.CreateDataSetForConfig(config);
using (var parser = new CsvParser(file.OpenText(), csvHelperConfig))
{
while (true)
{
if (config.SkipHeader)
{
SkipFirstHeaderLine(parser);
}
var row = parser.Read();
if (row == null)
{
break;
}
var recordType = recordSelector.SelectRecordForRow(config.CsvRecords, config, row);
var table = result.Tables[recordType.TableName];
var newRow = table.NewRow();
CsvFieldMapper.Mapfields(row, recordType, newRow);
table.Rows.Add(newRow);
}
}
return(result);
}
public void Upload(HttpPostedFileBase file)
{
var csvconf = new CsvHelper.Configuration.CsvConfiguration()
{
IsStrictMode = false,
SkipEmptyRecords = true,
IsCaseSensitive = false
};
csvconf.SkipEmptyRecords = true;
csvconf.ClassMapping <AppImportRowModel.CsvMap>();
var csvReader = new CsvReader(new System.IO.StreamReader(file.InputStream), csvconf);
var csvRows = csvReader.GetRecords <AppsImport>().Select(f =>
{
f.Id = this.Id;
f.InterlineTransfer = f.InterlineTransfer ?? false;
f.EndOfYearValidationOnly = f.EndOfYearValidationOnly ?? false;
return(f);
});
var idatareader = CC.Web.Helpers.idrf.GetReader(csvRows);
var sqlBulkCopy = GetSqlBulkCopy();
sqlBulkCopy.WriteToServer(idatareader);
}
public static void ParseCSV(string csvFile)
{
List <DataObject> readData = new List <DataObject>();
using (var reader = new StreamReader(csvFile))
{
CsvHelper.Configuration.CsvConfiguration cnfg =
new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
cnfg.Encoding = System.Text.Encoding.UTF8;
cnfg.Delimiter = ",";
cnfg.HasHeaderRecord = true;
cnfg.NewLine = System.Environment.NewLine;
cnfg.TrimOptions = CsvHelper.Configuration.TrimOptions.Trim;
using (var csv = new CsvReader(reader, cnfg))
{
//csv.Context.RegisterClassMap<CsvMap>();
readData = csv.GetRecords <DataObject>().ToList();
}
}
Console.WriteLine($"readData.Count={readData.Count}");
for (int i = 0; i < readData.Count; i++)
{
Console.WriteLine($"[{i}]: Name={readData[i].Name}; Code={readData[i].Code}; Quantity={readData[i].Quantity};");
}
}
internal static List <List <string> > ReadFromString(string csvContent, char delimiter)
{
if (string.IsNullOrEmpty(csvContent))
{
throw new System.ArgumentException("Empty CSV content. Cannot read CSV", "csvContent");
}
var rows = new List <List <string> >();
using (StringReader reader = new StringReader(csvContent))
{
var config = new CsvHelper.Configuration.CsvConfiguration();
config.Delimiter = delimiter.ToString();
var parser = new CsvParser(reader, config);
while (true)
{
var row = parser.Read();
if (row == null)
{
break;
}
rows.Add(new List <string>(row));
}
}
return(rows);
}
protected IEnumerable <T> ConvertDataToList <T>(TextReader tr)
{
IEnumerable <T> result = new List <T>();
CsvReader csvReader = null;
try
{
CsvHelper.Configuration.CsvConfiguration cnfg = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture)
{
HasHeaderRecord = true,
IgnoreBlankLines = true,
TrimOptions = CsvHelper.Configuration.TrimOptions.Trim
};
cnfg.RegisterClassMap(cnfg.AutoMap <T>());
csvReader = new CsvReader(tr, cnfg);
var list = csvReader.GetRecords <T>().ToList();
result = list;
}
finally
{
if (csvReader != null)
{
csvReader.Dispose();
}
}
return(result);
}
private static void WriteCsv(List <WixPortfolioImportRowModel> buffer)
{
var CsvFactory = new CsvHelper.Factory();
var configuration = new CsvHelper.Configuration.CsvConfiguration(System.Globalization.CultureInfo.CurrentCulture);
// Configure CSV reader
configuration.DetectColumnCountChanges = true;
configuration.HasHeaderRecord = true;
configuration.IgnoreBlankLines = true;
configuration.TrimOptions = CsvHelper.Configuration.TrimOptions.Trim;
configuration.Delimiter = ",";
configuration.IgnoreReferences = false;
// Map properties of row model to field headers in CSV file
configuration.RegisterClassMap <WixPortfolioImportCsvRowMap>();
var dateStamp = System.DateTime.Now.ToString("yyyy-MM-dd HHmmss");
var filename = $"{dateStamp} - Portfolio products import.csv";
using (var txtreader = new StreamWriter(filename))
{
using (var csv = CsvFactory.CreateWriter(txtreader, configuration))
{
csv.WriteRecords(buffer);
}
txtreader.Close();
}
}
private void UpdateAnalysisMongo(IEnumerable <PredictFile> files)
{
var newResults = new List <AnalysisResult>();
CsvHelper.Configuration.CsvConfiguration config =
new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture)
{
Delimiter = "|",
HeaderValidated = null
};
foreach (var file in files)
{
using (TextReader reader = new StringReader(file.Content))
using (var csv = new CsvReader(reader, config))
{
var records = csv.GetRecords <AnalysisResult>();
newResults.AddRange(records);
}
}
if (newResults.Count > 0)
{
foreach (var result in newResults)
{
this.analysisRepository.Create(result);
}
UpdateWordCount(newResults);
}
}
public void Generate()
{
var generator = Generator.Create(c =>
{
c.Entity <MemberImportModel>(e =>
{
e.Property(p => p.GivenName).DataSource <FirstNameSource>();
e.Property(p => p.FamilyName).DataSource <LastNameSource>();
e.Property(p => p.Email).Value(m => $"{m.GivenName}.{m.FamilyName}@mailinator.com");
e.Property(p => p.DisplayName).Value(m => $"{m.GivenName} {m.FamilyName}");
e.Property(p => p.SortName).Value(m => $"{m.FamilyName}, {m.GivenName}");
});
});
var users = generator.List <MemberImportModel>(20);
var configuration = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.CurrentCulture);
configuration.HasHeaderRecord = true;
using (var writer = new StreamWriter($"users-{DateTime.Now.Ticks}.csv"))
using (var csv = new CsvWriter(writer, configuration))
{
csv.WriteRecords(users);
}
}
public IActionResult OnGetAirports()
{
var csvConfiguration = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture)
{
BadDataFound = context => { },
};
FeatureCollection featureCollection = new FeatureCollection();
using (var sr = new StreamReader(Path.Combine(webHostEnvironment.WebRootPath, "airports.dat")))
using (var reader = new CsvReader(sr, csvConfiguration))
{
while (reader.Read())
{
string name = reader.GetField <string>(1);
string iataCode = reader.GetField <string>(4);
string latitude = reader.GetField <string>(6);
string longitude = reader.GetField <string>(7);
featureCollection.Features.Add(new Feature(
new Point(new Position(latitude, longitude)),
new Dictionary <string, object>
{
{ "name", name },
{ "iataCode", iataCode },
}));
}
}
return(new JsonResult(featureCollection));
}
public void MultipleCharDelimiterWithBufferEndingInMiddleOfDelimiterTest()
{
var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture)
{
Delimiter = "|~|",
BufferSize = 3,
};
using (var stream = new MemoryStream())
using (var reader = new StreamReader(stream))
using (var writer = new StreamWriter(stream))
using (var parser = new CsvParser(reader, config))
{
writer.WriteLine("1|~|2");
writer.Flush();
stream.Position = 0;
var row = parser.Read();
Assert.IsNotNull(row);
Assert.AreEqual(2, row.Length);
Assert.AreEqual("1", row[0]);
Assert.AreEqual("2", row[1]);
row = parser.Read();
Assert.IsNull(row);
}
}
static void Main(string[] args)
{
List<Int32> numbers = new List<Int32>();
// Путь к файлу numbers.csv
string path = "C:/numbers.csv";
// Создание потока чтения в файл
using (StreamReader streamRead = new StreamReader(path))
{
// Настраиваем разделитель csv файла
var config = new CsvHelper.Configuration.CsvConfiguration(System.Globalization.CultureInfo.CurrentCulture) { Delimiter = "," };
// Создание потока чтения csv файла на основе потока чтения файла
using (CsvReader csvRead = new CsvReader(streamRead, config))
{
// Считываем строку из файла numbers.csv
csvRead.Read();
// Цикл чтения столбцов
for (int i = 0; i < 100; i++)
{
// Считываем и выводим в консоль числа
numbers.Add(Convert.ToInt32(csvRead.GetField(i)));
}
}
}
numbers = Sortirovka(numbers);
for (int i = 0; i < 100; i++)
{
Console.WriteLine(numbers[i]);
}
}
public void CircularDependencyWithMultiplePropertiesTest()
{
var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
var map = config.AutoMap <A>();
Assert.AreEqual(1, map.MemberMaps.Count);
Assert.AreEqual(3, map.ReferenceMaps.Count);
}
private static void ConfigureCsv(CsvHelper.Configuration.CsvConfiguration csv)
{
csv.HasHeaderRecord = true;
csv.IgnoreBlankLines = true;
csv.IgnoreHeaderWhiteSpace = true;
csv.SkipEmptyRecords = true;
csv.TrimFields = true;
csv.IgnoreHeaderWhiteSpace = false;
}
private static async Task Main(string[] args)
{
var startup = new Startup(args);
var outputFolder = GlobalSettings.AppSettings.OutputFolder;
if (!Directory.Exists(outputFolder))
{
Directory.CreateDirectory(outputFolder);
}
var cultureInfo = (System.Globalization.CultureInfo)System.Globalization.CultureInfo.CurrentCulture.Clone();
cultureInfo.NumberFormat.NumberDecimalSeparator = ".";
cultureInfo.NumberFormat.NumberGroupSeparator = "";
var csvConf = new CsvHelper.Configuration.CsvConfiguration(cultureInfo)
{
Delimiter = "\t",
};
csvConf.TypeConverterCache.AddConverter <LocalDate>(new CustomConverter <LocalDate?> {
FromObject = value => value == null ? "" : value.Value.AtMidnight().ToDateTimeUnspecified().ToString("yyyy-MM-dd")
});
using (var main = ActivatorUtilities.CreateInstance <Main>(startup.Services))
{
var cmds = new List <Command> {
new CreateIndexCmd(main),
new CreateGroupedCmd(main),
new CreateHouseIndexCmd(main),
new ReadSBCHtml(GlobalSettings.AppSettings.StorageFolderSbcHtml),
new OCRImagesCmd(),
new InitCmd(main),
new JoinDataSources(GlobalSettings.AppSettings, main),
new ConvertInvoiceImageFilenameCmd(main),
new ObjectToFilenameAndObject(),
new GetAccountsListCmd(main),
new QuitCmd(),
new CSVCmd(csvConf),
new WriteFileCmd(outputFolder),
new WriteFiles(outputFolder),
new ReadFileCmd(outputFolder),
new AddCommandsTestCmd(),
new SIEResultsCmd(GlobalSettings.AppSettings)
};
cmds.Add(new ListCmd(cmds));
var REPLRunner = new Runner(cmds);
var readConsole = new ReadConsoleByChar("> ", new List <string> {
"l older", "l old"
});
await REPLRunner.RunREPL(readConsole, CancellationToken.None);
}
}
public static List <Locator> LoadLocators(string filePath)
{
CsvHelper.Configuration.CsvConfiguration config = new CsvHelper.Configuration.CsvConfiguration();
config.Encoding = Encoding.Default;
var path = System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
filePath = Path.Combine(path, filePath);
var csv = new CsvReader(new StreamReader(filePath, Encoding.Default));
return(csv.GetRecords <Locator>().ToList());
}
public void CircularDependencyTest()
{
var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
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);
}
private static CsvHelper.Configuration.CsvConfiguration GetConfig()
{
var config = new CsvHelper.Configuration.CsvConfiguration(System.Globalization.CultureInfo.CurrentCulture)
{
HasHeaderRecord = false,
AllowComments = false,
Delimiter = ","
};
return(config);
}
private static void VerifyTrace()
{
Console.WriteLine("Input trace log file or directory:");
var path = Console.ReadLine();
var files = new List <string>();
if (File.Exists(path))
{
files.Add(path);
}
else if (Directory.Exists(path))
{
files.AddRange(Directory.GetFiles(path));
}
else
{
throw new InvalidOperationException($"File or Directory '{path}' does not exist.");
}
foreach (var file in files)
{
if (file.EndsWith(".log"))
{
Console.WriteLine($"Reading file '{file}'.");
var logRecords = new List <LogRecord>();
using (var reader = new StreamReader(file))
{
var config = new CsvHelper.Configuration.CsvConfiguration(System.Globalization.CultureInfo.InvariantCulture)
{
HeaderValidated = null, MissingFieldFound = null, Delimiter = "|", HasHeaderRecord = false, BadDataFound = (b) => { Console.WriteLine($"Bad log line found: {b.RawRecord}"); }
};
using (var csv = new CsvReader(reader, config))
{
logRecords = csv.GetRecords <LogRecord>().ToList();
}
}
foreach (var record in logRecords)
{
if (record.LogLevel.Equals("Trace"))
{
var match = Regex.Match(record.Message, @"^Tracking ID '(\w+)'.$", RegexOptions.RightToLeft);
if (match.Success)
{
tagsToProcess.Add(new TagSeen {
TimeStamp = DateTime.Parse(record.DateTime), Epc = match.Captures[0].Value
});
}
}
}
}
}
}
public void EnsureInternalsAreSetupWhenPassingWriterAndConfigTest()
{
using (var stream = new MemoryStream())
using (var writer = new StreamWriter(stream))
{
var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
using (var csv = new CsvWriter(writer, config))
{
Assert.Same(config, csv.Configuration);
}
}
}
public void EnsureInternalsAreSetupWhenPassingReaderAndConfigTest()
{
using (var stream = new MemoryStream())
using (var reader = new StreamReader(stream))
{
var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture);
using (var parser = new CsvParser(reader, config))
{
Assert.AreSame(config, parser.Configuration);
}
}
}
public static TableData LoadDataFromfCSV(string fileName)
{
var configuration = new CsvHelper.Configuration.CsvConfiguration();
configuration.Delimiter = "\t";
configuration.HasExcelSeparator = false;
configuration.IgnoreQuotes = true;
configuration.QuoteNoFields = true;
using (var reader = new CsvReader(new StreamReader(fileName), configuration))
{
var data = new TableData();
var index = 0;
string[] headers = null;
while (reader.Read())
{
if (index == 0)
{
headers = reader.FieldHeaders;
for (var columnIndex = 0; columnIndex < headers.Length; columnIndex++)
{
var columnName = headers[columnIndex];
data.AddAttribute(columnName);
}
index++;
continue;
}
var row = data.NewRow();
for (var columnIndex = 0; columnIndex < headers.Length; columnIndex++)
{
var columnName = headers[columnIndex];
row[columnName] = reader.GetField(columnIndex);
}
data.AddRow(row);
}
return data;
}
}
public static SqlTable CsvToSqlTable(TextReader textReader, ISqlWriter sqlWriter, bool hasHeader = true, string delimiter = ",", int count = -1)
{
var config = new CsvHelper.Configuration.CsvConfiguration();
config.Delimiter = delimiter;
config.HasHeaderRecord = hasHeader;
var reader = new CsvHelper.CsvReader(textReader, config);
var rows = reader.GetRecords<object>().ToList();
textReader.Close();
SqlTable sqlTable = null;
if (rows.Count > 0)
{
sqlTable = new SqlTable();
sqlTable.Headers = new List<SqlColumnTypeDefinition>();
sqlTable.Rows = new List<SqlRow>();
var i = 0;
foreach (var row in rows)
{
if (i == count)
break;
i++;
var columns = (System.Dynamic.ExpandoObject)row;
var sqlRow = new SqlRow();
sqlTable.Rows.Add(sqlRow);
var countUnkown = 1;
foreach (var col in columns)
{
// set rows
var sqlColumn = new SqlColumn();
sqlColumn.Type = sqlWriter.SqlTypeToCSharpType(col.Value);
sqlColumn.Value = col.Value;
sqlRow.Columns.Add(sqlColumn);
// set headers
var key = col.Key;
if (string.IsNullOrWhiteSpace(key))
{
key = "Unkown" + countUnkown;
countUnkown++;
}
SqlColumnTypeDefinition sqlColumnTypeDefinition = sqlTable.Headers.FirstOrDefault(f => f.Name == key);
if (sqlColumnTypeDefinition == null)
{
sqlColumnTypeDefinition = new SqlColumnTypeDefinition();
sqlColumnTypeDefinition.Name = col.Key;
sqlColumnTypeDefinition.Type = sqlColumn.Type;
sqlTable.Headers.Add(sqlColumnTypeDefinition);
}
sqlColumn.ColumnTypeDefinition = sqlColumnTypeDefinition;
// override type of header to STRING because exists a string in the column
if (sqlColumnTypeDefinition.Type != typeof(string) && sqlColumn.Type == typeof(string))
sqlColumnTypeDefinition.Type = typeof(string);
}
}
// Fix type to STRING if all values is 'NULL'
foreach (var sqlHeader in sqlTable.Headers)
{
if (sqlHeader.Type == null)
sqlHeader.Type = typeof(string);
sqlHeader.TypeFormatted = sqlWriter.CSharpTypeToSqlType(sqlHeader.Type);
}
}
return sqlTable;
}
public void EndBufferTest()
{
var config = new CsvHelper.Configuration.CsvConfiguration
{
BufferSize = 12
};
using( var stream = new MemoryStream() )
using( var writer = new StreamWriter( stream ) )
using( var reader = new StreamReader( stream ) )
using( var parser = new CsvParser( reader, config ) )
{
writer.Write( "111,222,333\r\naaa,bbb,ccc\r\n" );
writer.Flush();
stream.Position = 0;
// BufferSize is set to 12 to force a buffer read after the first \r
var row = parser.Read();
Assert.IsNotNull( row );
Assert.AreEqual( "111", row[0] );
Assert.AreEqual( "222", row[1] );
Assert.AreEqual( "333", row[2] );
row = parser.Read();
Assert.IsNotNull( row );
Assert.AreEqual( "aaa", row[0] );
Assert.AreEqual( "bbb", row[1] );
Assert.AreEqual( "ccc", row[2] );
}
}
public static void ReadAll_CsvHelper(DelimitedRecordReaderBenchmarkArguments args)
{
var config = new CH.Configuration.CsvConfiguration
{
BufferSize = args.BufferSize,
AllowComments = true,
IgnoreBlankLines = args.SkipEmptyLines,
HasHeaderRecord = false,
DetectColumnCountChanges = true,
TrimFields = args.TrimWhiteSpaces,
TrimHeaders = args.TrimWhiteSpaces
};
using (var reader = new CH.CsvReader(new StreamReader(args.Path, args.Encoding, true, args.BufferSize), config))
{
string s;
if (args.FieldIndex < 0)
{
while (reader.Read())
{
var record = reader.CurrentRecord;
for (int i = 0; i < record.Length; i++)
s = record[i];
}
}
else
{
while (reader.Read())
{
for (int i = 0; i < args.FieldIndex + 1; i++)
s = reader[i];
}
}
}
}
static void Main(string[] args)
{
var path = string.Empty;
var questionNumber = 2;
#if DEBUG
path = "Test1.csv";
#else
if (!args.Any())
{
Console.WriteLine("You must enter the name of the csv file!");
return;
}
if (args.Length <= 2)
{
path = args[0];
}
if (args.Length >= 2)
{
questionNumber = Convert.ToInt32(args[1]);
}
#endif
var config = new CsvHelper.Configuration.CsvConfiguration();
config.SkipEmptyRecords = true;
config.WillThrowOnMissingField = false;
config.DetectColumnCountChanges = false;
var questions = new List<GameQuestionCsv>();
var allQuestions = new List<GameQuestionCsv>();
using (var textreader = File.OpenText(path))
{
var csv = new CsvReader(textreader);
var list = csv.GetRecords<GameQuestionCsv>().ToList();
allQuestions = list;
Random rnd = new Random();
var level1Questions =
list.OrderBy(user => rnd.Next()).Where(node => !node.HasSeen && node.Difficulty == 1).Take(questionNumber);
questions.AddRange(level1Questions);
var level2Questions =
list.OrderBy(user => rnd.Next()).Where(node => !node.HasSeen && node.Difficulty == 2).Take(questionNumber);
questions.AddRange(level2Questions);
var level3Questions =
list.OrderBy(user => rnd.Next()).Where(node => !node.HasSeen && node.Difficulty == 3).Take(questionNumber);
questions.AddRange(level3Questions);
var level4Questions =
list.OrderBy(user => rnd.Next()).Where(node => !node.HasSeen && node.Difficulty == 4).Take(questionNumber);
questions.AddRange(level4Questions);
var level5Questions =
list.OrderBy(user => rnd.Next()).Where(node => !node.HasSeen && node.Difficulty == 5).Take(questionNumber);
questions.AddRange(level5Questions);
foreach (var question in questions)
{
question.HasSeen = true;
var oldQuestion = allQuestions.First(node => node.QKEY == question.QKEY);
oldQuestion.HasSeen = true;
}
}
var json = JsonConvert.SerializeObject(questions, Formatting.Indented);
File.WriteAllText("questions.json", json);
using (var textWriter = new StreamWriter("Edited_" + path))
{
var csv = new CsvWriter(textWriter);
csv.WriteRecords(questions);
}
}
