Beste Weg, um eine große Datei in ein Byte-Array in C# zu lesen?

Question

Ich habe einen Webserver, der große Binärdateien (mehrere Megabyte) in Byte-Arrays liest. Der Server könnte mehrere Dateien gleichzeitig lesen (verschiedene Seitenanfragen), so dass ich auf der Suche nach dem optimierten Weg, dies zu tun, ohne die CPU zu sehr zu belasten. Ist der folgende Code gut genug?

public byte[] FileToByteArray(string fileName)
{
    byte[] buff = null;
    FileStream fs = new FileStream(fileName, 
                                   FileMode.Open, 
                                   FileAccess.Read);
    BinaryReader br = new BinaryReader(fs);
    long numBytes = new FileInfo(fileName).Length;
    buff = br.ReadBytes((int) numBytes);
    return buff;
}

Answer 1

Ersetzen Sie das Ganze einfach durch:

return File.ReadAllBytes(fileName);

Wenn Sie jedoch über den Speicherverbrauch besorgt sind, sollten Sie no die gesamte Datei auf einmal in den Speicher zu lesen. Sie sollten das in Abschnitten tun.

Answer 2

Ich würde sagen, dass die Antwort hier allgemein ist "nicht". Es sei denn, Sie unbedingt notwendig alle Daten auf einmal zu erfassen, sollten Sie ein Stream -basierten API (oder einer Variante von Reader/Iterator). Das heißt insbesondere wichtig, wenn Sie mehrere parallele Operationen durchführen (wie in der Frage vorgeschlagen), um die Systemlast zu minimieren und den Durchsatz zu maximieren.

Zum Beispiel, wenn Sie Daten an einen Anrufer streamen:

Stream dest = ...
using(Stream source = File.OpenRead(path)) {
    byte[] buffer = new byte[2048];
    int bytesRead;
    while((bytesRead = source.Read(buffer, 0, buffer.Length)) > 0) {
        dest.Write(buffer, 0, bytesRead);
    }
}

Answer 3

Ich würde dies denken:

byte[] file = System.IO.File.ReadAllBytes(fileName);

Answer 4

Ihr Code kann hierauf abgestimmt werden (anstelle von File.ReadAllBytes):

public byte[] ReadAllBytes(string fileName)
{
    byte[] buffer = null;
    using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read))
    {
        buffer = new byte[fs.Length];
        fs.Read(buffer, 0, (int)fs.Length);
    }
    return buffer;
} 

Beachten Sie die Begrenzung der Dateigröße durch die Read-Methode (Integer.MaxValue). Mit anderen Worten: Sie können nur einen 2 GB großen Brocken auf einmal lesen.

Beachten Sie auch, dass das letzte Argument des FileStream eine Puffergröße ist.

Ich würde auch empfehlen, etwas über FileStream y BufferedStream .

Wie immer ist ein einfaches Beispielprogramm zur Erstellung eines Profils, das am schnellsten ist, von großem Nutzen.

Auch die zugrunde liegende Hardware hat einen großen Einfluss auf die Leistung. Verwenden Sie serverbasierte Festplattenlaufwerke mit großem Cache und eine RAID-Karte mit integriertem Speicher-Cache? Oder verwenden Sie ein Standardlaufwerk, das an den IDE-Anschluss angeschlossen ist?

Answer 5

Ich würde sagen BinaryReader ist in Ordnung, kann aber auf diese Weise umgestaltet werden, anstatt all dieser Codezeilen, um die Länge des Puffers zu ermitteln:

public byte[] FileToByteArray(string fileName)
{
    byte[] fileData = null;

    using (FileStream fs = File.OpenRead(fileName)) 
    { 
        using (BinaryReader binaryReader = new BinaryReader(fs))
        {
            fileData = binaryReader.ReadBytes((int)fs.Length); 
        }
    }
    return fileData;
}

Sollte besser sein als die Verwendung von .ReadAllBytes() da ich in den Kommentaren zu der oberen Antwort gesehen habe, dass auch .ReadAllBytes() dass einer der Kommentatoren Probleme mit Dateien > 600 MB hatte, da ein BinaryReader ist für diese Art von Dingen gedacht. Auch das Einlegen in eine using Anweisung stellt sicher, dass die FileStream y BinaryReader werden geschlossen und entsorgt.