Como dividir um arquivo grande em pedaços em c #?

Eu estou fazendo um remetente de transferência de arquivo simples e um aplicativo receptor através do fio. O que eu tenho até agora é que o remetente converte o arquivo em um array de bytes e envia pedaços desse array para o receptor.

Isso funciona com arquivo de até 256mb , mas acima de tudo, a linha:

 byte[] buffer = StreamFile(fileName); //This is where I convert the file Throws a System out of memory exception. 

Eu estou procurando uma maneira de ler o arquivo em pedaços, em seguida, escrever esse pedaço em vez de carregar o arquivo inteiro em um byte . Como posso fazer isso com um FileStream ?

EDITAR:

Desculpe, heres meu código de baixa qualidade até agora:

  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(); } 

E aqui está como eu recebo (o código foi de um tutorial)

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

Eu realmente quero saber como eu posso ler o arquivo em pedaços para que eu não precise convertê-lo em um byte.

Obrigado pelas respostas até agora, acho que estou começando a entender: D

Apenas chame Read repetidamente com um pequeno buffer (eu costumo usar algo como 16K). Observe que a chamada para Read pode acabar lendo uma quantidade menor do que a solicitada. Se você estiver usando um tamanho de bloco fixo e precisar de todo o pedaço na memory, você pode simplesmente usar um array desse tamanho, é claro.

Sem saber como você está enviando o arquivo, é difícil dar muitos conselhos sobre como estruturar seu código, mas pode ser algo assim:

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

Se eu estivesse mais acordado, provavelmente encontraria uma maneira mais legível de escrever isso, mas o fará por agora. Uma opção é extrair outro método da seção intermediária:

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

Você já olhou para o WCF Streaming? Aqui está um bom artigo no MSDN que descreve os resources do WCF para stream de GB de dados.

Grandes dados e streaming