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

Je nach Häufigkeit der Vorgänge, der Größe der Dateien und der Anzahl der Dateien, die Sie betrachten, gibt es weitere Leistungsaspekte zu berücksichtigen. Eine Sache, die Sie bedenken sollten, ist, dass jedes Ihrer Byte-Arrays dem Garbage Collector ausgeliefert ist. Wenn Sie die Daten nicht zwischenspeichern, könnten Sie am Ende eine Menge Müll erzeugen und einen Großteil Ihrer Leistung an % Zeit in GC . Wenn die Chunks größer als 85K sind, werden sie dem Large Object Heap (LOH) zugewiesen, der eine Sammlung aller Generationen erfordert, um sie freizugeben (dies ist sehr teuer und auf einem Server wird die gesamte Ausführung angehalten, während dies geschieht). Außerdem kann es bei einer großen Anzahl von Objekten im LOH zu einer Fragmentierung des LOH kommen (der LOH wird nie komprimiert), was zu einer schlechten Leistung und zu Ausnahmen bei Speicherplatzmangel führt. Sie können den Prozess ab einem bestimmten Punkt wiederverwenden, aber ich weiß nicht, ob das die beste Vorgehensweise ist.

Der Punkt ist, dass Sie den gesamten Lebenszyklus Ihrer Anwendung berücksichtigen sollten, bevor Sie unbedingt alle Bytes auf dem schnellstmöglichen Weg in den Speicher einlesen, da Sie sonst die kurzfristige Leistung gegen die Gesamtleistung eintauschen.

Answer 2

Falls mit "eine große Datei" eine Datei jenseits der 4GB-Grenze gemeint ist, dann ist meine nachfolgend geschriebene Code-Logik angemessen. Der wichtigste Punkt ist der mit der SEEK-Methode verwendete LONG-Datentyp. Ein LONG ist in der Lage, über 2^32 Datengrenzen hinaus zu zeigen. In diesem Beispiel verarbeitet der Code zunächst die große Datei in 1-GB-Blöcken. Nachdem die großen 1-GB-Blöcke verarbeitet wurden, werden die restlichen (<1 GB) Bytes verarbeitet. Ich verwende diesen Code für die Berechnung des CRC von Dateien, die größer als 4 GB sind. (mit https://crc32c.machinezoo.com/ für die crc32c-Berechnung in diesem Beispiel)

private uint Crc32CAlgorithmBigCrc(string fileName)
{
    uint hash = 0;
    byte[] buffer = null;
    FileInfo fileInfo = new FileInfo(fileName);
    long fileLength = fileInfo.Length;
    int blockSize = 1024000000;
    decimal div = fileLength / blockSize;
    int blocks = (int)Math.Floor(div);
    int restBytes = (int)(fileLength - (blocks * blockSize));
    long offsetFile = 0;
    uint interHash = 0;
    Crc32CAlgorithm Crc32CAlgorithm = new Crc32CAlgorithm();
    bool firstBlock = true;
    using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read))
    {
        buffer = new byte[blockSize];
        using (BinaryReader br = new BinaryReader(fs))
        {
            while (blocks > 0)
            {
                blocks -= 1;
                fs.Seek(offsetFile, SeekOrigin.Begin);
                buffer = br.ReadBytes(blockSize);
                if (firstBlock)
                {
                    firstBlock = false;
                    interHash = Crc32CAlgorithm.Compute(buffer);
                    hash = interHash;
                }
                else
                {
                    hash = Crc32CAlgorithm.Append(interHash, buffer);
                }
                offsetFile += blockSize;
            }
            if (restBytes > 0)
            {
                Array.Resize(ref buffer, restBytes);
                fs.Seek(offsetFile, SeekOrigin.Begin);
                buffer = br.ReadBytes(restBytes);
                hash = Crc32CAlgorithm.Append(interHash, buffer);
            }
            buffer = null;
        }
    }
    //MessageBox.Show(hash.ToString());
    //MessageBox.Show(hash.ToString("X"));
    return hash;
}

Answer 3

Überblick: Wenn Ihr Bild als action= eingebettete Ressource hinzugefügt wird, verwenden Sie GetExecutingAssembly, um die jpg-Ressource in einen Stream zu laden, und lesen Sie dann die binären Daten im Stream in ein Byte-Array

   public byte[] GetAImage()
    {
        byte[] bytes=null;
        var assembly = Assembly.GetExecutingAssembly();
        var resourceName = "MYWebApi.Images.X_my_image.jpg";

        using (Stream stream = assembly.GetManifestResourceStream(resourceName))
        {
            bytes = new byte[stream.Length];
            stream.Read(bytes, 0, (int)stream.Length);
        }
        return bytes;

    }

Answer 4

Verwenden Sie die BufferedStream-Klasse in C#, um die Leistung zu verbessern. Ein Puffer ist ein Block von Bytes im Speicher, der zum Zwischenspeichern von Daten verwendet wird, wodurch die Anzahl der Aufrufe an das Betriebssystem verringert wird. Puffer verbessern die Lese- und Schreibleistung.

Im Folgenden finden Sie ein Codebeispiel und weitere Erläuterungen: http://msdn.microsoft.com/en-us/library/system.io.bufferedstream.aspx

Answer 5

Dies verwenden:

 bytesRead = responseStream.ReadAsync(buffer, 0, Length).Result;