C# CsvReader.ReadDataRecordsAsync方法代码示例

        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 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>
        /// 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;
        }