C# CsvWriter.WriteRecordsAsync方法代码示例

        /// <summary>
        /// Asynchronously copies all remaining records in <paramref name="this"/> to <paramref name="destination"/>.
        /// </summary>
        /// <param name="this">
        /// The data source.
        /// </param>
        /// <param name="destination">
        /// The data destination.
        /// </param>
        /// <returns>
        /// The number of records written to <paramref name="destination"/>.
        /// </returns>
        public async static Task<int> CopyToAsync(this CsvReader @this, CsvWriter destination)
        {
            @this.AssertNotNull("@this");
            destination.AssertNotNull("destination");

            var num = 0;
            var buffer = new DataRecord[16];
            var read = 0;

            while ((read = await @this.ReadDataRecordsAsync(buffer, 0, buffer.Length).ConfigureAwait(false)) != 0)
            {
                await destination.WriteRecordsAsync(buffer, 0, read).ConfigureAwait(false);
                num += read;
            }

            return num;
        }

        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
        }

        public async Task write_records_async_writes_only_specified_records_to_text_writer()
        {
            using (var stringWriter = new StringWriter())
            {
                using (var writer = new CsvWriter(stringWriter))
                {
                    var buffer = new RecordBase[]
                    {
                        new DataRecord(null, new string[] { "one", "two", "three" }),
                        new DataRecord(null, new string[] { "four", "five", "six" }),
                        new DataRecord(null, new string[] { "seven", "eight", "nine" }),
                        new DataRecord(null, new string[] { "ten" })
                    };

                    await writer.WriteRecordsAsync(buffer, 1, 2);
                }

                var expectedCsv = @"four,five,six
seven,eight,nine
";

                Assert.Equal(expectedCsv, stringWriter.ToString());
            }
        }

        public async Task write_records_async_increments_record_number()
        {
            using (var writer = new CsvWriter(new MemoryStream()))
            {
                var buffer = new RecordBase[]
                {
                    new DataRecord(null, new string[] { "one", "two", "three" }),
                    new DataRecord(null, new string[] { "four", "five", "six" }),
                    new DataRecord(null, new string[] { "seven", "eight", "nine", "ten" })
                };

                await writer.WriteRecordsAsync(buffer, 0, buffer.Length);
                Assert.Equal(3, writer.RecordNumber);
            }
        }

        public async Task write_records_async_throws_if_any_included_record_within_the_buffer_is_null()
        {
            using (var writer = new CsvWriter(new MemoryStream()))
            {
                var buffer = new RecordBase[]
                {
                    new HeaderRecord(),
                    new HeaderRecord(),
                    new HeaderRecord(),
                    null,
                    new HeaderRecord()
                };

                writer.WriteRecords(buffer, 0, 3);

                await Assert.ThrowsAsync<ArgumentException>(() => writer.WriteRecordsAsync(buffer, 0, 4));
            }
        }

 public async Task write_records_async_throws_if_length_is_invalid()
 {
     using (var writer = new CsvWriter(new MemoryStream()))
     {
         await Assert.ThrowsAsync<ArgumentException>(() => writer.WriteRecordsAsync(new RecordBase[100], 0, 101));
         await Assert.ThrowsAsync<ArgumentException>(() => writer.WriteRecordsAsync(new RecordBase[100], 90, 20));
     }
 }

 public async Task write_records_async_throws_if_buffer_is_null()
 {
     using (var writer = new CsvWriter(new MemoryStream()))
     {
         await Assert.ThrowsAsync<ArgumentNullException>(() => writer.WriteRecordsAsync(null, 0, 1));
     }
 }

 public async Task write_records_async_throws_if_disposed()
 {
     var writer = new CsvWriter(new MemoryStream());
     writer.Dispose();
     await Assert.ThrowsAsync<ObjectDisposedException>(() => writer.WriteRecordsAsync(new RecordBase[1], 0, 1));
 }

        /// <summary>
        /// Asynchronously writes all rows in <paramref name="this"/> to <paramref name="csvWriter"/>.
        /// </summary>
        /// <remarks>
        /// </remarks>
        /// <param name="this">
        /// The <see cref="DataTable"/>.
        /// </param>
        /// <param name="csvWriter">
        /// The <see cref="CsvWriter"/>.
        /// </param>
        /// <param name="writeHeaderRecord">
        /// If <see langword="true"/>, a header record will also be written, which will be comprised of the column names defined for <paramref name="this"/>.
        /// </param>
        /// <param name="maximumRows">
        /// The maximum number of rows from <paramref name="this"/> that should be written to <paramref name="csvWriter"/>.
        /// </param>
        /// <param name="objectToStringConverter">
        /// Provides a means of converting values in the <see cref="DataRow"/>s to <see cref="String"/>s.
        /// </param>
        /// <returns>
        /// The actual number of rows from <paramref name="this"/> written to <paramref name="csvWriter"/>.
        /// </returns>
        public async static Task<int> WriteCsvAsync(this DataTable @this, CsvWriter csvWriter, bool writeHeaderRecord, int? maximumRows, Func<object, string> objectToStringConverter)
        {
            @this.AssertNotNull("@this");
            csvWriter.AssertNotNull("csvWriter");
            objectToStringConverter.AssertNotNull("objectToStringConverter");

            var num = 0;

            if (writeHeaderRecord)
            {
                var columnNames = new string[@this.Columns.Count];

                for (var i = 0; i < columnNames.Length; ++i)
                {
                    columnNames[i] = @this.Columns[i].ColumnName;
                }

                await csvWriter.WriteRecordAsync(columnNames).ConfigureAwait(false);
            }

            var maximum = maximumRows.GetValueOrDefault(int.MaxValue);
            var buffer = new DataRecord[16];
            var bufferOffset = 0;

            foreach (DataRow row in @this.Rows)
            {
                var record = new DataRecord();

                for (var i = 0; i < row.ItemArray.Length; ++i)
                {
                    record.Add(objectToStringConverter(row.ItemArray[i]));
                }

                buffer[bufferOffset++] = record;

                if (bufferOffset == buffer.Length)
                {
                    // buffer full
                    await csvWriter.WriteRecordsAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
                    bufferOffset = 0;
                }

                if (++num == maximum)
                {
                    break;
                }
            }

            // write any outstanding data in buffer
            await csvWriter.WriteRecordsAsync(buffer, 0, bufferOffset).ConfigureAwait(false);

            return num;
        }