我将记录写入CSV格式，以便通过外部API作为文件上传，该API对上传文件的大小有限制。我将记录写入内存的方法如下：
```C#
using CsvHelper;
public async Task<byte[]> WriteToMemoryAsync<T>(IEnumerable<T> recordsToWrite) where T : class
{
    using (var memoryStream = new MemoryStream())
    {
        using (var writer = new StreamWriter(memoryStream))
        using (var csv = new CsvWriter(writer, new CultureInfo("sv-SE")))
        {
            await csv.WriteRecordsAsync(recordsToWrite);
        }
        return memoryStream.ToArray();
    }
}

public async Task<Dictionary<int, byte[]>> BatchWriteToMemoryAsync<T>(IEnumerable<T> recordsToWrite) where T : class
{
    var maxBatchSize = 50_000;
    var nrOfBatches = (int)Math.Ceiling((double)recordsToWrite.Count() / maxBatchSize);
    Dictionary<int, byte[]> records = new();
    for (int batchNr = 0; batchNr < nrOfBatches; batchNr++)
    {
        records.Add(batchNr, await WriteToMemoryAsync<T>(recordsToWrite));
    }
    return records;
}

[Fact]
public void WhenWritingToMemoryInBatches_ShouldEnsureFileSizeDoesNotExceedLimit()
{
    //安排
    var records = GenerateTestRecords(100);
    var fileSizeLimit = 1_000;  //1000B 限制
    var csvHandler = new CsvHandler();
    //操作
    var file = csvHandler.BatchWriteToMemory(records, fileSizeLimit);
    //断言
    Assert.All(file, f => Assert.True(f.Length < fileSizeLimit, $"Expected fileSize to be less than {fileSizeLimit}. Actual fileSize was {f.Length}."));
}
private IEnumerable<TestRecord> GenerateTestRecords(int amountOfRecords)
{
    List<TestRecord> records = new();
    for (int i = 0; i < amountOfRecords; i++)
    {
        records.Add(new TestRecord
        {
            StringType = $"String {i}",
            IntType = 1,
        });
    }
    return records;
}
private class TestRecord
{
    public string? StringType { get; set; }
    public int IntType { get; set; }
}

<details>
<summary>英文:</summary>
I&#39;m writing records into a csv format in order to upload it as a file through an external API that has a file size limit on the uploads. My method for writing records to memory looks like this:

    }
    return memoryStream.ToArray();
}

My current approach for batching looks like this:

var nrOfBatches = (int)Math.Ceiling((double)recordsToWrite.Count() / maxBatchSize);
Dictionary<int, byte[]> records = new();
for (int batchNr = 0; batchNr < nrOfBatches; batchNr++)
{
    records.Add(batchNr, await WriteToMemoryAsync<T>(recordsToWrite));
}
return records;

The problem is that the batch size is sort of arbitrary. Depending on how large objects ``T`` includes this might fail.  
> Is there any way to get the size in bytes of the ``IEnumerable<T>`` in order to get an approximation of the file size and then determine the number of batches based on this? 
> Is there any other way to approach this?
## Edit ##
----------
I've now implemented the first solution that Magnus suggested. However, there is a problem with flushing the written record before checking the length of the stream as the stream has already passed the size limit at that point. 
I created a test to simulate the problem and this fails as the batch size hits 1009B for the first batch.

var fileSizeLimit = 1_000;  //1000B limit
var csvHandler = new CsvHandler();
//Act
var file = csvHandler.BatchWriteToMemory(records, fileSizeLimit);
//Assert
Assert.All(file, f => Assert.True(f.Length < fileSizeLimit, $"Expected fileSize to be less than {fileSizeLimit}. Actual fileSize was {f.Length}."));

</details>
# 答案1
**得分**: 2
如果将所有项目发送到 `WriteToMemory`，然后检查流的大小，如果达到所需大小，则返回写入的项目并初始化下一批的新流。因此，`WriteToMemory` 将返回一组批次。
可能不希望在每次写入记录后都刷新，找到合适的刷新间隔。
```csharp
    public static IEnumerable<byte[]> WriteToMemory<T>(IEnumerable<T> recordsToWrite)
    {
        var memoryStream = new MemoryStream();
        var writer = new StreamWriter(memoryStream);
        var csv = new CsvWriter(writer, new CultureInfo("sv-SE"));
        try
        {
            foreach (var r in recordsToWrite)
            {
                csv.WriteRecord(r);
                csv.Flush(); // 可能希望在每 x 个项目后刷新，而不是每个项目。
                if (memoryStream.Length >= 1024)
                {
                    csv.Dispose();
                    writer.Dispose();
                    memoryStream.Dispose();
                    yield return memoryStream.ToArray();
                    memoryStream = new MemoryStream();
                    writer = new StreamWriter(memoryStream);
                    csv = new CsvWriter(writer, new CultureInfo("sv-SE"));
                }
            }
            csv.Flush();
            if (memoryStream.Length > 0)
                yield return memoryStream.ToArray();
        }
        finally
        {
            csv.Dispose();
            writer.Dispose();
            memoryStream.Dispose();
        }
    }

    public class Program
    {
        private static int count = 0;
        public static async Task Main()
        {
            await WriteToStreamAsync(Enumerable.Range(0, 10_000), () => File.Create($"C:\\temp\\files\\file{count++}.csv"));
        }
        public static async Task WriteToStreamAsync<T>(IEnumerable<T> recordsToWrite, Func<Stream> createFile)
        {
            var stream = createFile();
            var writer = new StreamWriter(stream);
            var csv = new CsvWriter(writer, new CultureInfo("sv-SE"));
            try
            {
                var i = 0;
                foreach (var r in recordsToWrite)
                {
                    csv.WriteRecord(r);
                    if (++i % 100 == 0) // 找到一些良好的间隔
                        await csv.FlushAsync();
                    if (stream.Length >= 1024)
                    {
                        await csv.DisposeAsync();
                        await writer.DisposeAsync();
                        await stream.DisposeAsync();
                        stream = createFile();
                        writer = new StreamWriter(stream);
                        csv = new CsvWriter(writer, new CultureInfo("sv-SE"));
                    }
                }
            }
            finally
            {
                await csv.DisposeAsync();
                await writer.DisposeAsync();
                await stream.DisposeAsync();
            }
        }
    }