MemoryStream - 数据被截断[重复]答案

【问题标题】：MemoryStream - Data getting truncated [duplicate]MemoryStream - 数据被截断[重复]
【发布时间】：2021-03-10 18:36:32
【问题描述】：

原始问题 - CSV 文件太大 (700k) 记录 - 因此希望从那个大 CSV 文件创建更小的 CSV 文件。

得到以下代码来剖析文件并创建更小的文件。

 private async Task SplitFile(List<CsvRow> rows, string name)
    {
        var numRows = 30000;

        var remainder = rows.Count() % numRows;
        var chunks = rows.Count() / numRows;

        if (remainder > 0)
        {
            chunks++;
        }

        // Iterate rows in chunks
        for (var row = 0; row < chunks; row++)
        {
            // Extract chunks using LINQ
            var fileRows = rows
                .Skip(row * numRows)
                .Take(numRows)
                .ToList();

            var outputPath = Path.Combine(@"c:\", $"file{row}.txt");
            var encoding = new UTF8Encoding(true);
            
            await using var mem = new MemoryStream();
            await using var fileWriter = new StreamWriter(outputPath, false, encoding);
            await using var writer = new StreamWriter(mem, encoding);
            await using var csvBlob = new CsvWriter(writer, CultureInfo.InvariantCulture);
            await using var csvFile = new CsvWriter(fileWriter, CultureInfo.InvariantCulture);

            await csvFile.WriteRecordsAsync(fileRows);
            await csvBlob.WriteRecordsAsync(fileRows);

            FileStream file = new FileStream(@$"c:\memfile{row}.txt", FileMode.Create,
                FileAccess.Write);
            mem.WriteTo(file);
            file.Close();
        }
    }

Blocker - 我正在从 Azure Blob 容器下载原始大文件，并在创建小块后将它们上传回 Blob 容器。为此，我需要将数据保存在 MemoryStreams 中。

我创建物理文件只是为了解决内存流问题。更容易调试。

当我运行上面的代码时 - 小块文件被创建。你会注意到我正在创建两组文件（块）

首先，直接将数据写入File Stream，其次，使用我创建的MemoryStream。

我在通过直接写入文件流创建的文件中获得 30000 条记录，但在第二个文件中我只获得 29889 条记录。

我尝试了所有方法，但在使用 MemoryStream 时无法立即获取所有 30000 条记录。

我刷新了流，摆弄了编码，但没有任何帮助。我读到了带有 BOM 的 UTF8。看起来很有希望，但又无法解决。

我使用的是 Dot Net Core 3.1

MemoryStream 是否存在已知问题。为什么它丢失了最后几条记录？其余文件相同。

有什么想法吗？

谢谢

【问题讨论】：

在调用 WriteRecordsAsync 之后、复制到输出文件之前尝试调用 csvBlob.Flush()。我怀疑 CsvWriter 维护一个需要刷新到 MemoryStream 的内部缓冲区，这可能会在您调用 Close/Dispose 时发生。但是，直到您复制内存流之后才会进行处置，因此当您复制到输出文件时，csv 数据不会完全刷新到内存流中。
几乎所有 I/O 对象都包含缓冲，并且在尝试使用它们正在写入的其他对象之前未能刷新和/或关闭此类对象将导致数据被截断。查看重复项。

标签： c# csv .net-core memorystream csvhelper

【解决方案1】：

正如我在上面评论的，解决方法是在复制MemoryStream 之前在CsvWriter 上调用Flush。问题是在CsvWriter 内部缓冲区中仍有待处理的数据不会被复制到MemoryStream，直到你Flush 它。这应该会让事情对你有用。

但是，我对您的方案有更深入的反馈。在处理批次之前，您似乎正在将整个 700K 文件读入List<CsvRow>。更好的方法是从 Azure 流式传输 CSV 数据，然后在阅读时将较小的批次发送回 Azure。

在此示例中，我将使用我自己的库 (Sylvan.Data.Csv)，但我确信 CsvHelper 提供了类似的功能。

using Sylvan.Data.Csv;

...

string name = "MyMassiveCsv";
TextReader reader = File.OpenText(name + ".csv");

// replace above with however you access your Azure blob streams.

CsvDataReader csv = await CsvDataReader.CreateAsync(reader);

RangeDataReader r;
int i = 0;
do
{
    r = new RangeDataReader(csv, 30000);
    i++;

    using var writer = File.CreateText(name + i + ".csv");
    // using var writer = new StreamWriter(CreateAzureBlob("batch" + i));
    using var w = CsvDataWriter.Create(writer);

    await w.WriteAsync(r);
} while (!r.AtEndOfData);

这样您一次只需要在内存中保存少量的 CSV 文件，您将立即开始批量发回，而不必先下载整个 CSV。

RangeDataReader 是一个 DbDataReader 实现，它包装了一个 DbDataReader 并限制了它从底层读取器读取的行数。实现如下：

using System;
using System.Collections;
using System.Data.Common;
using System.Threading;
using System.Threading.Tasks;

class RangeDataReader : DbDataReader
{
    readonly DbDataReader reader;

    int row = -1;
    int count;

    public RangeDataReader(DbDataReader dataReader, int count)
    {
        this.reader = dataReader;
        this.count = count;
    }


    public bool AtEndOfData { get; private set; }

    public override async Task<bool> ReadAsync(CancellationToken cancellationToken)
    {
        if (row < count)
        {
            row++;
            var r = await reader.ReadAsync(cancellationToken);
            if (!r)
            {
                AtEndOfData = r;
            }
            return r;
        }
        return false;
    }

    public override bool Read()
    {
        if (row < count)
        {
            row++;
            var r = reader.Read();
            if (!r)
            {
                AtEndOfData = r;
            }
            return r;
        }
        return false;
    }

    public override object this[int ordinal] => this.GetValue(ordinal);

    public override object this[string name] => this.GetValue(GetOrdinal(name));

    public override int Depth => 0;

    public override int FieldCount => reader.FieldCount;

    public override bool HasRows => reader.HasRows;

    public override bool IsClosed => reader.IsClosed;

    public override int RecordsAffected => reader.RecordsAffected;


    public override bool GetBoolean(int ordinal)
    {
        return reader.GetBoolean(ordinal);
    }

    public override byte GetByte(int ordinal)
    {
        return reader.GetByte(ordinal);
    }

    public override long GetBytes(int ordinal, long dataOffset, byte[]? buffer, int bufferOffset, int length)
    {
        return reader.GetBytes(ordinal, dataOffset, buffer, bufferOffset, length);
    }

    public override char GetChar(int ordinal)
    {
        return reader.GetChar(ordinal);
    }

    public override long GetChars(int ordinal, long dataOffset, char[]? buffer, int bufferOffset, int length)
    {
        return reader.GetChars(ordinal, dataOffset, buffer, bufferOffset, length);
    }

    public override string GetDataTypeName(int ordinal)
    {
        return reader.GetDataTypeName(ordinal);
    }

    public override DateTime GetDateTime(int ordinal)
    {
        return reader.GetDateTime(ordinal);
    }

    public override decimal GetDecimal(int ordinal)
    {
        return reader.GetDecimal(ordinal);
    }

    public override double GetDouble(int ordinal)
    {
        return reader.GetDouble(ordinal);
    }

    public override IEnumerator GetEnumerator()
    {
        return new DbEnumerator(this);
    }

    public override Type GetFieldType(int ordinal)
    {
        return reader.GetFieldType(ordinal);
    }

    public override float GetFloat(int ordinal)
    {
        return reader.GetFloat(ordinal);
    }

    public override Guid GetGuid(int ordinal)
    {
        return reader.GetGuid(ordinal);
    }

    public override short GetInt16(int ordinal)
    {
        return reader.GetInt16(ordinal);
    }

    public override int GetInt32(int ordinal)
    {
        return reader.GetInt32(ordinal);
    }

    public override long GetInt64(int ordinal)
    {
        return reader.GetInt64(ordinal);
    }

    public override string GetName(int ordinal)
    {
        return reader.GetName(ordinal);
    }

    public override int GetOrdinal(string name)
    {
        return reader.GetOrdinal(name);
    }

    public override string GetString(int ordinal)
    {
        return reader.GetString(ordinal);
    }

    public override object GetValue(int ordinal)
    {
        return reader.GetValue(ordinal);
    }

    public override int GetValues(object[] values)
    {
        return reader.GetValues(values);
    }

    public override bool IsDBNull(int ordinal)
    {
        return reader.IsDBNull(ordinal);
    }

    public override bool NextResult()
    {
        throw new NotSupportedException();
    }
}

几乎所有内容都委托给内部数据读取器。唯一有趣的是Read/ReadAsync，它限制了它将读取的行数。我还没有彻底测试过这段代码，现在看看它，我可能会在它将读取的行数上相差一个。

最后，既然我已经说明了如何对 CSV 数据进行流式处理，那么拆分的需求可能就消失了，您可以简单地流式处理文件而不需要拆分它？如果不知道更多关于为什么你觉得你需要拆分它，很难知道。

【讨论】：