C # bir bayt dizisi içine büyük bir dosyayı okumak için en iyi yolu?

Bayt dizilerine büyük ikili dosyaları (birkaç megabayt) okuyacak bir web sunucum var. Sunucu aynı anda birkaç dosya (farklı sayfa istekleri) okuma olabilir, bu yüzden CPU çok fazla vergi vermeden bunu yapmak için en iyi şekilde arıyorum. Aşağıdaki kod yeterince iyi mi?

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

Sadece her şeyi şu şekilde değiştirin:

return File.ReadAllBytes(fileName);

Eğer bellek tüketimi hakkında endişe varsa Ancak, gereken değil tüm tek seferde en belleğe tüm dosyayı okuyun. Bunu parçalar halinde yapmalısın.

Buradaki cevabın genellikle "yapma" olduğunu söyleyebilirim . Tüm verilere bir kerede kesinlikle ihtiyacınız olmadığı sürece , Streamtabanlı bir API (veya okuyucu / yineleyicinin bir çeşidi) kullanmayı düşünün . Yani özellikle sistem yükünü azaltmak ve veri maksimize etmek (soru önerdiği gibi) birden çok paralel işlemleri olduğunda önemli.

Örneğin, bir arayan kişiye veri akışı yapıyorsanız:

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

Bunu düşünürdüm:

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

Kodunuz buna göre hesaplanabilir (File.ReadAllBytes yerine):

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

Read yöntemi tarafından yerleştirilen Integer.MaxValue - dosya boyutu sınırlamasına dikkat edin. Başka bir deyişle, aynı anda yalnızca 2 GB'lık bir yığın okuyabilirsiniz.

Ayrıca, FileStream öğesinin son bağımsız değişkeninin bir arabellek boyutu olduğuna dikkat edin.

Ayrıca FileStream ve BufferedStream hakkında okuma öneririm .

Her zaman olduğu gibi en hızlı profil oluşturmak için basit bir örnek program en faydalı olacaktır.

Ayrıca, temel donanımınızın performans üzerinde büyük etkisi olacaktır. Büyük önbellekli sunucu tabanlı sabit disk sürücüleri ve yerleşik bellek önbelleğine sahip bir RAID kartı mı kullanıyorsunuz? Yoksa IDE bağlantı noktasına bağlı standart bir sürücü mü kullanıyorsunuz?

İşlemlerin sıklığına, dosyaların boyutuna ve baktığınız dosya sayısına bağlı olarak, dikkate alınması gereken başka performans sorunları da vardır. Hatırlanması gereken bir şey, her bayt dizinizin çöp toplayıcısının merhametinde serbest bırakılacağıdır. Bu verilerin hiçbirini önbelleğe almıyorsanız, çok fazla çöp oluşturabilir ve performansınızın çoğunu GC'deki% Time'a kaybedebilirsiniz.. Parçalar 85K'dan büyükse, serbest bırakmak için tüm nesillerin bir koleksiyonunu gerektiren Büyük Nesne Yığını'na (LOH) tahsis edeceksiniz (bu çok pahalıdır ve bir sunucuda devam ederken tüm yürütmeyi durduracaktır. ). Ek olarak, LOH üzerinde bir ton nesneniz varsa, düşük performansa ve bellek dışı istisnalara yol açan LOH parçalanması (LOH asla sıkıştırılmaz) ile sonuçlanabilir. Belli bir noktaya geldiğinizde süreci geri dönüştürebilirsiniz, ancak bunun en iyi uygulama olup olmadığını bilmiyorum.

Mesele şu ki, tüm baytları belleğe mümkün olan en hızlı şekilde okumadan önce uygulamanızın tam yaşam döngüsünü düşünmelisiniz veya genel performans için kısa vadeli performansla ticaret yapıyor olabilirsiniz.

Ben iyi olduğunu söyleyebilirim BinaryReader, ancak tampon uzunluğu almak için tüm bu kod satırları yerine, bu yeniden düzenlenebilir:

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

Kullanmaktan daha iyi olmalı .ReadAllBytes(), çünkü .ReadAllBytes()yorumculardan birinin 600 MB'lık dosyalarla ilgili sorunları olduğunu içeren en üst yanıttaki yorumlarda gördüğümden , çünkü BinaryReaderbu tür bir şey için tasarlanmıştır. Ayrıca, bir usingifadeye koymak FileStreamve BinaryReaderkapalı ve atılmasını sağlar.

'Büyük bir dosya' 4GB sınırını aşarsa, aşağıdaki yazılı kod mantığım uygundur. Dikkat edilmesi gereken en önemli husus, SEEK yöntemiyle kullanılan UZUN veri türüdür. Bir UZUN 2 ^ 32 veri sınırlarını aşabildiğinden. Bu örnekte, kod ilk olarak büyük dosyayı 1 GB'lık parçalar halinde işliyor, büyük 1 GB'lık büyük parçalar işlendikten sonra, kalan (<1GB) baytlar işleniyor. Ben 4GB boyutu ötesinde dosyaların CRC hesaplanması ile bu kodu kullanın. ( bu örnekte crc32c hesaplaması için https://crc32c.machinezoo.com/ adresini kullanarak )

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

Performansı artırmak için C # 'daki BufferedStream sınıfını kullanın. Bir arabellek, verileri önbelleğe almak için kullanılan ve böylece işletim sistemine yapılan çağrıların sayısını azaltan bellekte bir bayt bloğudur. Tamponlar okuma ve yazma performansını artırır.

Kod örneği ve ek açıklama için aşağıdakilere bakın: http://msdn.microsoft.com/en-us/library/system.io.bufferedstream.aspx

bunu kullan:

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

Ben Response.TransferFile()sonra a Response.Flush()ve Response.End()büyük dosyalarınızı sunmak için yöntemi denemenizi tavsiye ederim .

2 GB'ın üzerindeki dosyalarla ilgileniyorsanız, yukarıdaki yöntemlerin başarısız olduğunu göreceksiniz.

Akışı MD5'e vermek ve dosyanızı sizin için yığınlamasına izin vermek çok daha kolaydır :

private byte[] computeFileHash(string filename)
{
    MD5 md5 = MD5.Create();
    using (FileStream fs = new FileStream(filename, FileMode.Open))
    {
        byte[] hash = md5.ComputeHash(fs);
        return hash;
    }
}