如何在c#中将一个大文件分割成块

本文关键字：一个 文件 分割 | 更新日期: 2023-09-27 17:50:14

我正在通过电线制作一个简单的文件传输发送者和接收者应用程序。到目前为止，我所知道的是发送方将文件转换为字节数组，并将该数组的块发送给接收方。

这适用于最高为256mb的文件，但是这一行会抛出"System out of memory"

byte[] buffer = StreamFile(fileName); //This is where I convert the file

我正在寻找一种方法来读取文件块，然后写块，而不是加载整个文件到byte。我怎么能做到这一点与FileStream ?

编辑:

对不起，这是我目前为止的蹩脚代码:

    private void btnSend(object sender, EventArgs e)
    {
        Socket clientSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

        byte[] fileName = Encoding.UTF8.GetBytes(fName); //file name
        byte[] fileData = null;
        try
        {
             fileData = StreamFile(textBox1.Text); //file
        }
        catch (OutOfMemoryException ex)
        {
            MessageBox.Show("Out of memory");
            return;
        }
        byte[] fileNameLen = BitConverter.GetBytes(fileName.Length); //length of file name
        clientData = new byte[4 + fileName.Length + fileData.Length];
        fileNameLen.CopyTo(clientData, 0);
        fileName.CopyTo(clientData, 4);
        fileData.CopyTo(clientData, 4 + fileName.Length);
        clientSock.Connect("172.16.12.91", 9050);
        clientSock.Send(clientData, 0, 4 + fileName.Length, SocketFlags.None);
        for (int i = 4 + fileName.Length; i < clientData.Length; i++)
        {
            clientSock.Send(clientData, i, 1 , SocketFlags.None);
        }
        clientSock.Close();
    }

这是我如何接收(代码来自教程)

   public void ReadCallback(IAsyncResult ar)
    {
        int fileNameLen = 1;
        String content = String.Empty;
        StateObject state = (StateObject)ar.AsyncState;
        Socket handler = state.workSocket;
        int bytesRead = handler.EndReceive(ar);
        if (bytesRead > 0)
        {
            if (flag == 0)
            {
                Thread.Sleep(1000);
                fileNameLen = BitConverter.ToInt32(state.buffer, 0);
                string fileName = Encoding.UTF8.GetString(state.buffer, 4, fileNameLen);
                receivedPath = fileName;
                flag++;
            }
                if (flag >= 1)
                {
                    BinaryWriter writer = new BinaryWriter(File.Open(receivedPath, FileMode.Append));
                    if (flag == 1)
                    {
                        writer.Write(state.buffer, 4 + fileNameLen, bytesRead - (4 + fileNameLen));
                        flag++;
                    }
                    else
                        writer.Write(state.buffer, 0, bytesRead);
                        writer.Close();
                        handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                        new AsyncCallback(ReadCallback), state);
                }
        }
        else
        {
            Invoke(new MyDelegate(LabelWriter));
        }
    }

我真的很想知道我如何读取文件块，这样我就不需要将其转换为字节。

谢谢你的回复，我想我开始明白了:D

如何在c#中将一个大文件分割成块

只需使用一个小缓冲区(我倾向于使用类似16K的东西)重复调用Read。注意，对Read的调用可能最终读取的小于您请求的量。如果你使用一个固定的块大小，并且需要整个块在内存中，你当然可以使用这个大小的数组。

在不知道如何发送文件的情况下，很难给出关于如何构建代码的建议，但它可以是这样的:

byte[] chunk = new byte[MaxChunkSize];
while (true)
{
    int index = 0;
    // There are various different ways of structuring this bit of code.
    // Fundamentally we're trying to keep reading in to our chunk until
    // either we reach the end of the stream, or we've read everything we need.
    while (index < chunk.Length)
    {
        int bytesRead = stream.Read(chunk, index, chunk.Length - index);
        if (bytesRead == 0)
        {
            break;
        }
        index += bytesRead;
    }
    if (index != 0) // Our previous chunk may have been the last one
    {
        SendChunk(chunk, index); // index is the number of bytes in the chunk
    }
    if (index != chunk.Length) // We didn't read a full chunk: we're done
    {
        return;
    }
}

如果我更清醒，我可能会找到一个更可读的方式来写这篇文章，但现在就这样做了。一种选择是从中间部分提取另一个方法:

// Attempts to read an entire chunk into the given array; returns the size of
// chunk actually read.
int ReadChunk(Stream stream, byte[] chunk)
{
    int index = 0;
    while (index < chunk.Length)
    {
        int bytesRead = stream.Read(chunk, index, chunk.Length - index);
        if (bytesRead == 0)
        {
            break;
        }
        index += bytesRead;
    }
    return index;
}

var b = new byte[1<<15]; // 32k
while((count = inStream.Read(b, 0, b.Length)) > 0)
{
  outStream.Write(b, 0, count);
}

 public static IEnumerable<byte[]> SplitStreamIntoChunks(Stream stream, int chunkSize)
    {
      var bytesRemaining = stream.Length;
      while (bytesRemaining > 0)
      {
        var size = Math.Min((int) bytesRemaining, chunkSize);
        var buffer = new byte[size];
        var bytesRead = stream.Read(buffer, 0, size);
        if (bytesRead <= 0)
          break;
        yield return buffer;
        bytesRemaining -= bytesRead;
      }
    }
相关文章：