OutOfMemoryException, wenn ich Lesen 500MB FileStream

Den code, den Sie zeigen, liest alle Inhalte der 500mb Datei in einen zusammenhängenden Bereich im Speicher.
Es ist nicht verwunderlich, dass Sie ein " out-of-memory-Bedingung.

Die Lösung ist, "Tu das nicht."

Was sind Sie wirklich versucht, zu tun?

Wenn Sie möchten, Lesen Sie eine Datei vollständig, es ist viel einfacher als die ReadFully Methode, die Sie verwenden. Versuchen Sie dies:

using (var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read)) 
{ 
   byte[] buffer = new byte[fs.Length];
   int bytesRead = fs.Read(buffer, 0, buffer.Length);
   //buffer now contains the entire contents of the file
} 

Aber... mit diesem code wird nicht Ihr problem lösen. Es könnte funktionieren, für eine 500 MB-Datei. Es wird nicht funktionieren, für eine 750 MB Datei oder eine 1 GB-Datei. Irgendwann erreichen Sie die Grenze von Speicher auf Ihrem system und Sie haben die gleiche out-of-memory-Fehler, den Sie begonnen haben.

Das problem ist, dass Sie versuchen, halten Sie den gesamten Inhalt der Datei im Speicher auf einmal. Dies ist in der Regel unnötig und zum scheitern verurteilt ist, da die Dateien in der Größe wachsen. Es ist kein problem, wenn die Dateigröße ist 16k. Auf 500 MB, es ist der falsche Ansatz.

Diesem Grund habe ich mich mehrmals gefragt, was sind Sie wirklich versuchen, zu tun ?

Klingt wie Sie wollen, senden Sie den Inhalt einer Datei aus, um eine ASPNET-Antwort-stream. Das ist die Frage. Nicht "wie zu Lesen, eine 500mb Datei in den Speicher?" Aber "gewusst wie: senden einer großen Datei, um den ASPNET-Response-stream???"

Für dieses, wieder einmal, es ist ziemlich einfach.

//emit the contents of a file into the ASPNET Response stream
using (var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read)) 
{ 
   Response.BufferOutput= false;   //to prevent buffering
   byte[] buffer = new byte[1024];
   int bytesRead = 0;
   while ((bytesRead = fs.Read(buffer, 0, buffer.Length)) > 0) 
   {
       Response.OutputStream.Write(buffer, 0, bytesRead);
   }
} 

Was es tut, ist iterativ, Lesen Sie ein Stück von der Datei, und schreiben Sie das Stück an das Response-stream, bis es nichts mehr zu Lesen in der Datei. Dies ist, was gemeint ist mit "streaming-IO". Die Daten übergibt, durch Ihre Logik, aber nie alle an einem Ort, der nur als ein Strom von Wasser fließt durch die Schleuse. In diesem Beispiel, es gibt nie mehr als 1k Daten im Speicher zu einer Zeit (gut, nicht von den Ihre Anwendung code, sowieso. Es gibt auch andere IO-Puffer tiefer im stack.)

Dies ist ein gemeinsames Muster in IO gestreamt. Lernen Sie es, verwenden Sie es.

Den einen trick beim Pumpen Daten aus ASPNET-Antwort.Ausgabestrom zu setzen, ist BufferOutput = false. Standardmäßig ASPNET versucht, Puffer, dessen Ausgang. In diesem Fall (500mb Datei), die Pufferung ist eine schlechte Idee. Einstellung der BufferOutput - Eigenschaft auf false wird verhindert, ASPNET aus dem Versuch, alle Puffer die Daten der Datei vor dem senden des ersten byte. Verwenden Sie, wenn Sie wissen, dass die Datei, die Sie senden, ist sehr groß. Die Daten werden noch zugestellt bekommen, der browser richtig.

- Und auch dies nicht die vollständige Lösung. Sie müssen die Antwort-Header und so weiter. Ich denke, Sie sind sich bewusst, dass, obwohl.

InformationsquelleAutor Cheeso

Asp.Net Core Middleware

public static async Task<string> GetRequestBody(HttpContext context)
    {
        string bodyText = string.Empty;
        try
        {
            var requestbody = context.Request.Body;
            context.Request.EnableRewind();
            int offset = 0, bytesread = 0;
            var buffer = new byte[5096];
            while ((bytesread = await context.Request.Body.ReadAsync(buffer, offset, buffer.Length - offset)) > 0)
            {
                offset += bytesread;
                if (offset == buffer.Length)
                {
                    int nextByte = context.Request.Body.ReadByte();
                    if (nextByte == -1)
                    {
                        break;
                    }
                    byte[] newBuffer = new byte[buffer.Length * 2];
                    Array.Copy(buffer, newBuffer, buffer.Length);//how to avoid copy 
                    newBuffer[offset] = (byte)nextByte;//how to avoid boxing 
                    buffer = newBuffer;
                    offset++;
                }
                if (offset > 4194304)
                {
                    //log.Warn("Middleware/GetRequestBody--> Request length exceeding limit");
                    break;
                }
            }
            bodyText = Encoding.UTF8.GetString(buffer);
        }
        catch (Exception ex)
        {
            //log.Debug(ex, "Middleware/GetRequestBody--> Request length exceeding limit");
        }
        context.Request.Body.Position = 0;
        return bodyText;
    }

InformationsquelleAutor Sunil Dhappadhule