Wie Sie split eine große Datei in Stücke, die in c#?

Mache ich eine einfache Datei-übertragung sender-und Empfänger-app durch den Draht. Was ich habe, so weit ist, dass der sender wandelt die Datei in ein byte-array und sendet Blöcken des Arrays an den Empfänger.

Dies funktioniert mit der Datei von bis zu 256mb, aber alles über die Zeile:

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

Throws a System out of memory exception.

Ich bin auf der Suche nach einem Weg, die Datei zu Lesen, in Abschnitten, dann schreiben Sie das Stück statt laden die ganze Datei in ein byte. Wie kann ich dies mit einem FileStream?

EDIT:

Sorry, heres my crappy code so weit:

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

Und hier ist, wie ich erhalten (das war der code aus einem 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));
        }

    }

Ich möchte wirklich wissen, wie ich die Datei gelesen werden kann in Blöcken, so dass ich nicht brauchen, zu konvertieren, um ein byte.

Danke für die Antworten so weit, ich glaube, ich fange an, es zu bekommen 😀

wird keine solche Methode gefunden StreamFile, können Sie mir sagen, welche library sollte ich auch?

InformationsquelleAutor Raphael | 2011-04-14

c#file filestream tcp

Einfach anrufen Read immer wieder mit einem kleinen Puffer (ich Neige dazu, verwenden Sie so etwas wie 16K). Beachten Sie, dass der Aufruf Read können am Ende der Lektüre ein kleinere Menge, als Sie verlangen. Wenn Sie eine Feste chunk-Größe und müssen den ganzen Brocken im Speicher, man könnte einfach ein array der Größe natürlich.

Ohne zu wissen, wie man senden die Datei, es ist schwer, zu viel Ratschläge wie Sie Ihren code strukturieren, aber es könnte so etwas wie dieses:

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

Wenn ich wach wäre, würde ich wahrscheinlich finden, eine besser lesbare Möglichkeit, dies zu schreiben, aber werde es jetzt tun. Eine Möglichkeit ist, extrahieren Sie eine andere Methode aus dem mittleren Abschnitt:

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

Danke für dieses

InformationsquelleAutor Jon Skeet

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

InformationsquelleAutor Talljoe

2

Haben Sie schaute in WCF Streaming? Hier ist ein guter Artikel auf der MSDN-Website, beschreibt die Funktionen der WCF zu Streamen GBs von Daten.

Große Daten-und Streaming -

InformationsquelleAutor Dave White

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.