/// <summary>
/// Populates <paramref name="this"/> with data read asynchronously from <paramref name="csvReader"/>.
/// </summary>
/// <remarks>
/// <para>
/// All records from <paramref name="csvReader"/> will be read and added to the table.
/// </para>
/// <para>
/// If <paramref name="this"/> has columns defined, those columns will be used when populating the data. If no columns have been defined, <paramref name="csvReader"/> must have a
/// <see cref="HeaderRecord"/>, which is then used to define the columns for <paramref name="this"/>. If any data record has more values than can fit into the columns defined on
/// <paramref name="this"/>, an exception is thrown.
/// </para>
/// </remarks>
/// <param name="this">
/// The <see cref="DataTable"/>.
/// </param>
/// <param name="csvReader">
/// The <see cref="CsvReader"/>.
/// </param>
/// <returns>
/// The number of rows added to <paramref name="this"/> (and therefore the number of data records read from <paramref name="csvReader"/>).
/// </returns>
public async static Task<int> FillAsync(this DataTable @this, CsvReader csvReader)
{
return await @this.FillAsync(csvReader, null).ConfigureAwait(false);
}
private static void CopyCSVFileToStringWriter()
{
#region CopyCSVFileToStringWriter
using (var stringWriter = new StringWriter())
{
using (var streamReader = new StreamReader("PlanetaryData.csv"))
using (var reader = new CsvReader(streamReader))
using (var writer = new CsvWriter(stringWriter))
{
writer.ValueSeparator = '\t';
writer.ValueDelimiter = '\'';
reader.CopyTo(writer);
}
Console.WriteLine(stringWriter);
}
#endregion
}
private static async Task CopyCSVFileToStringWriterAsynchronously()
{
#region CopyCSVFileToStringWriterAsynchronously
using (var stringWriter = new StringWriter())
{
using (var streamReader = new StreamReader("PlanetaryData.csv"))
using (var reader = new CsvReader(streamReader))
using (var writer = new CsvWriter(stringWriter))
{
writer.ValueSeparator = '\t';
writer.ValueDelimiter = '\'';
await reader.CopyToAsync(writer);
}
Console.WriteLine(stringWriter);
}
#endregion
}
private static async Task FillDataTableFromCSVFileAsynchronously()
{
#region FillDataTableFromCSVFileAsynchronously
var table = new DataTable();
using (var streamReader = new StreamReader("PlanetaryData.csv"))
using (var reader = new CsvReader(streamReader))
{
await reader.ReadHeaderRecordAsync();
await table.FillAsync(reader);
}
Console.WriteLine("Table contains {0} rows.", table.Rows.Count);
#endregion
}
private async static Task FillDataTableFromCSVFileThenWriteSomeToStringAsynchronously()
{
#region FillDataTableFromCSVFileThenWriteSomeToStringAsynchronously
var table = new DataTable();
using (var streamReader = new StreamReader("PlanetaryData.csv"))
using (var reader = new CsvReader(streamReader))
{
await reader.ReadHeaderRecordAsync();
await table.FillAsync(reader);
}
using (var stringWriter = new StringWriter())
{
using (var writer = new CsvWriter(stringWriter))
{
await table.WriteCsvAsync(writer, false, 5);
}
Console.WriteLine("CSV: {0}", stringWriter);
}
#endregion
}
/// <summary>
/// Creates a table in <paramref name="this"/> and populates it with data read asynchronously from <paramref name="csvReader"/>.
/// </summary>
/// <remarks>
/// <para>
/// All records from <paramref name="csvReader"/> will be read and added to the table.
/// </para>
/// <para>
/// <paramref name="csvReader"/> must have a <see cref="HeaderRecord"/>, which is used to populate the column names of the <see cref="DataTable"/>.
/// </para>
/// </remarks>
/// <param name="this">
/// The <see cref="DataSet"/>.
/// </param>
/// <param name="csvReader">
/// The <see cref="CsvReader"/>.
/// </param>
/// <param name="tableName">
/// The name of the table to create and add to <paramref name="this"/>
/// </param>
/// <returns>
/// The number of rows added to the <see cref="DataTable"/> (and therefore the number of data records read from <paramref name="csvReader"/>).
/// </returns>
public async static Task<int> FillAsync(this DataSet @this, CsvReader csvReader, string tableName)
{
return await @this.FillAsync(csvReader, tableName, null).ConfigureAwait(false);
}
/// <summary>
/// Populates <paramref name="this"/> with data read from <paramref name="csvReader"/>.
/// </summary>
/// <remarks>
/// <para>
/// All records from <paramref name="csvReader"/> will be read and added to the table.
/// </para>
/// <para>
/// If <paramref name="this"/> has columns defined, those columns will be used when populating the data. If no columns have been defined, <paramref name="csvReader"/> must have a
/// <see cref="HeaderRecord"/>, which is then used to define the columns for <paramref name="this"/>. If any data record has more values than can fit into the columns defined on
/// <paramref name="this"/>, an exception is thrown.
/// </para>
/// </remarks>
/// <param name="this">
/// The <see cref="DataTable"/>.
/// </param>
/// <param name="csvReader">
/// The <see cref="CsvReader"/>.
/// </param>
/// <returns>
/// The number of rows added to <paramref name="this"/> (and therefore the number of data records read from <paramref name="csvReader"/>).
/// </returns>
public static int Fill(this DataTable @this, CsvReader csvReader)
{
return @this.Fill(csvReader, null);
}
private static void ReadCSVFromFileWithExplicitHeader()
{
#region ReadCSVFromFileWithExplicitHeader
using (var streamReader = new StreamReader("PlanetaryData_NoHeader.csv"))
using (var reader = new CsvReader(streamReader))
{
reader.HeaderRecord = new HeaderRecord("OfficialName", "NickName");
while (reader.HasMoreRecords)
{
var dataRecord = reader.ReadDataRecord();
Console.WriteLine("{0} is nicknamed {1}.", dataRecord["OfficialName"], dataRecord["NickName"]);
reader.SkipRecord();
}
}
#endregion
}
private async static Task ReadCSVFromFileAsynchronously()
{
#region ReadCSVFromFileAsynchronously
using (var textReader = new StreamReader("PlanetaryData.csv"))
using (var reader = new CsvReader(textReader, true))
{
await reader.ReadHeaderRecordAsync();
// realistically, you'll probably want a larger buffer, but this suffices for demonstration purposes
var buffer = new DataRecord[4];
while (reader.HasMoreRecords)
{
var read = await reader.ReadDataRecordsAsync(buffer, 0, buffer.Length);
for (var i = 0; i < read; ++i)
{
Console.WriteLine("{0} is nicknamed {1}.", buffer[i]["Name"], buffer[i]["Nickname"]);
}
}
}
#endregion
}
private static void ReadCSVFromFile()
{
#region ReadCSVFromFile
using (var streamReader = new StreamReader("PlanetaryData.csv"))
using (var reader = new CsvReader(streamReader))
{
// the CSV file has a header record, so we read that first
reader.ReadHeaderRecord();
while (reader.HasMoreRecords)
{
var dataRecord = reader.ReadDataRecord();
// since the reader has a header record, we can access data by column names as well as by index
Console.WriteLine("{0} is nicknamed {1}.", dataRecord[0], dataRecord["Nickname"]);
}
}
#endregion
}
private static void ReadCSVFromStream()
{
#region ReadCSVFromStream
using (var stream = new FileStream("PlanetaryData.csv", FileMode.Open))
using (var reader = new CsvReader(stream, Encoding.UTF8))
{
reader.ReadHeaderRecord();
while (reader.HasMoreRecords)
{
var dataRecord = reader.ReadDataRecord();
Console.WriteLine("{0} is nicknamed {1}.", dataRecord["Name"], dataRecord["Nickname"]);
}
}
#endregion
}
private static void ReadTabDelimitedDataFromFile()
{
#region ReadTabDelimitedDataFromFile
using (var streamReader = new StreamReader("PlanetaryData.tdv"))
using (var reader = new CsvReader(streamReader))
{
reader.ValueSeparator = '\t';
reader.ValueDelimiter = '\'';
while (reader.HasMoreRecords)
{
var dataRecord = reader.ReadDataRecord();
Console.WriteLine("{0} is nicknamed {1}.", dataRecord[0], dataRecord[dataRecord.Count - 1]);
}
}
#endregion
}
/// <summary>
/// Creates a table in <paramref name="this"/> and populates it with data read from <paramref name="csvReader"/>.
/// </summary>
/// <remarks>
/// <para>
/// All records from <paramref name="csvReader"/> will be read and added to the table.
/// </para>
/// <para>
/// <paramref name="csvReader"/> must have a <see cref="HeaderRecord"/>, which is used to populate the column names of the <see cref="DataTable"/>.
/// </para>
/// </remarks>
/// <param name="this">
/// The <see cref="DataSet"/>.
/// </param>
/// <param name="csvReader">
/// The <see cref="CsvReader"/>.
/// </param>
/// <param name="tableName">
/// The name of the table to create and add to <paramref name="this"/>
/// </param>
/// <returns>
/// The number of rows added to the <see cref="DataTable"/> (and therefore the number of data records read from <paramref name="csvReader"/>).
/// </returns>
public static int Fill(this DataSet @this, CsvReader csvReader, string tableName)
{
return @this.Fill(csvReader, tableName, null);
}
/// <summary>
/// Creates a table in <paramref name="this"/> and populates it with data read from <paramref name="csvReader"/>.
/// </summary>
/// <remarks>
/// <para>
/// The name of the table created and added to <paramref name="this"/> is <see cref="DefaultTableName"/>. All records from <paramref name="csvReader"/> will be read and added to the table.
/// </para>
/// <para>
/// <paramref name="csvReader"/> must have a <see cref="HeaderRecord"/>, which is used to populate the column names of the <see cref="DataTable"/>.
/// </para>
/// </remarks>
/// <param name="this">
/// The <see cref="DataSet"/>.
/// </param>
/// <param name="csvReader">
/// The <see cref="CsvReader"/>.
/// </param>
/// <returns>
/// The number of rows added to the <see cref="DataTable"/> (and therefore the number of data records read from <paramref name="csvReader"/>).
/// </returns>
public static int Fill(this DataSet @this, CsvReader csvReader)
{
return @this.Fill(csvReader, DefaultTableName);
}
/// <summary>
/// Populates <paramref name="this"/> with data read asynchronously from <paramref name="csvReader"/>.
/// </summary>
/// <remarks>
/// <para>
/// If <paramref name="this"/> has columns defined, those columns will be used when populating the data. If no columns have been defined, <paramref name="csvReader"/> must have a
/// <see cref="HeaderRecord"/>, which is then used to define the columns for <paramref name="this"/>. If any data record has more values than can fit into the columns defined on
/// <paramref name="this"/>, an exception is thrown.
/// </para>
/// </remarks>
/// <param name="this">
/// The <see cref="DataTable"/>.
/// </param>
/// <param name="csvReader">
/// The <see cref="CsvReader"/>.
/// </param>
/// <param name="maximumRecords">
/// The maximum number of records to read and add to <paramref name="this"/>.
/// </param>
/// <returns>
/// The number of rows added to <paramref name="this"/> (and therefore the number of data records read from <paramref name="csvReader"/>).
/// </returns>
public async static Task<int> FillAsync(this DataTable @this, CsvReader csvReader, int? maximumRecords)
{
@this.AssertNotNull("@this");
csvReader.AssertNotNull("csvReader");
exceptionHelper.ResolveAndThrowIf(maximumRecords.GetValueOrDefault() < 0, "maximumRecordsMustBePositive");
if (@this.Columns.Count == 0)
{
// table has no columns, so we need to use the CSV header record to populate them
exceptionHelper.ResolveAndThrowIf(csvReader.HeaderRecord == null, "noColumnsAndNoHeaderRecord");
foreach (var columnName in csvReader.HeaderRecord)
{
@this.Columns.Add(columnName);
}
}
var remaining = maximumRecords.GetValueOrDefault(int.MaxValue);
var buffer = new DataRecord[16];
while (remaining > 0)
{
var read = await csvReader.ReadDataRecordsAsync(buffer, 0, Math.Min(buffer.Length, remaining)).ConfigureAwait(false);
if (read == 0)
{
// no more data
break;
}
for (var i = 0; i < read; ++i)
{
var record = buffer[i];
exceptionHelper.ResolveAndThrowIf(record.Count > @this.Columns.Count, "moreValuesThanColumns", @this.Columns.Count, record.Count);
var recordAsStrings = new string[record.Count];
record.CopyTo(recordAsStrings, 0);
@this.Rows.Add(recordAsStrings);
}
remaining -= read;
}
return maximumRecords.GetValueOrDefault(int.MaxValue) - remaining;
}
private async static Task ReadCSVFromFileAndWriteToTabDelimitedFile()
{
#region ReadCSVFromFileAndWriteToTabDelimitedFile
using (var streamReader = new StreamReader("PlanetaryData.csv"))
using (var reader = new CsvReader(streamReader))
using (var streamWriter = new StreamWriter("PlanetaryData_Modified.csv"))
using (var writer = new CsvWriter(streamWriter))
{
writer.ValueSeparator = '\t';
writer.ValueDelimiter = '\'';
// realistically, you'll probably want a larger buffer, but this suffices for demonstration purposes
var buffer = new DataRecord[4];
while (reader.HasMoreRecords)
{
var read = await reader.ReadDataRecordsAsync(buffer, 0, buffer.Length);
await writer.WriteRecordsAsync(buffer, 0, read);
}
}
#endregion
}
/// <summary>
/// Creates a table in <paramref name="this"/> and populates it with data read asynchronously from <paramref name="csvReader"/>.
/// </summary>
/// <remarks>
/// <para>
/// The name of the table created and added to <paramref name="this"/> is <see cref="DefaultTableName"/>. All records from <paramref name="csvReader"/> will be read and added to the table.
/// </para>
/// <para>
/// <paramref name="csvReader"/> must have a <see cref="HeaderRecord"/>, which is used to populate the column names of the <see cref="DataTable"/>.
/// </para>
/// </remarks>
/// <param name="this">
/// The <see cref="DataSet"/>.
/// </param>
/// <param name="csvReader">
/// The <see cref="CsvReader"/>.
/// </param>
/// <returns>
/// The number of rows added to the <see cref="DataTable"/> (and therefore the number of data records read from <paramref name="csvReader"/>).
/// </returns>
public async static Task<int> FillAsync(this DataSet @this, CsvReader csvReader)
{
return await @this.FillAsync(csvReader, DefaultTableName).ConfigureAwait(false);
}
private static void FillDataTableFromCSVFile()
{
#region FillDataTableFromCSVFile
var table = new DataTable();
using (var streamReader = new StreamReader("PlanetaryData.csv"))
using (var reader = new CsvReader(streamReader))
{
reader.ReadHeaderRecord();
table.Fill(reader);
}
Console.WriteLine("Table contains {0} rows.", table.Rows.Count);
#endregion
}
/// <summary>
/// Creates a table in <paramref name="this"/> and populates it with data read asynchronously from <paramref name="csvReader"/>.
/// </summary>
/// <remarks>
/// <para>
/// <paramref name="csvReader"/> must have a <see cref="HeaderRecord"/>, which is used to populate the column names of the <see cref="DataTable"/>.
/// </para>
/// </remarks>
/// <param name="this">
/// The <see cref="DataSet"/>.
/// </param>
/// <param name="csvReader">
/// The <see cref="CsvReader"/>.
/// </param>
/// <param name="tableName">
/// The name of the table to create and add to <paramref name="this"/>
/// </param>
/// <param name="maximumRecords">
/// The maximum number of records to read and add to the <see cref="DataTable"/>.
/// </param>
/// <returns>
/// The number of rows added to the <see cref="DataTable"/> (and therefore the number of data records read from <paramref name="csvReader"/>).
/// </returns>
public async static Task<int> FillAsync(this DataSet @this, CsvReader csvReader, string tableName, int? maximumRecords)
{
@this.AssertNotNull("@this");
tableName.AssertNotNull("tableName");
var table = @this.Tables.Add(tableName);
return await table.FillAsync(csvReader, maximumRecords).ConfigureAwait(false);
}
/// <summary>
/// Creates a table in <paramref name="this"/> and populates it with data read from <paramref name="csvReader"/>.
/// </summary>
/// <remarks>
/// <para>
/// <paramref name="csvReader"/> must have a <see cref="HeaderRecord"/>, which is used to populate the column names of the <see cref="DataTable"/>.
/// </para>
/// </remarks>
/// <param name="this">
/// The <see cref="DataSet"/>.
/// </param>
/// <param name="csvReader">
/// The <see cref="CsvReader"/>.
/// </param>
/// <param name="tableName">
/// The name of the table to create and add to <paramref name="this"/>
/// </param>
/// <param name="maximumRecords">
/// The maximum number of records to read and add to the <see cref="DataTable"/>.
/// </param>
/// <returns>
/// The number of rows added to the <see cref="DataTable"/> (and therefore the number of data records read from <paramref name="csvReader"/>).
/// </returns>
public static int Fill(this DataSet @this, CsvReader csvReader, string tableName, int? maximumRecords)
{
@this.AssertNotNull("@this");
tableName.AssertNotNull("tableName");
var table = @this.Tables.Add(tableName);
return table.Fill(csvReader, maximumRecords);
}