Найкращий спосіб прочитати великий файл у байтовому масиві на C #?

У мене є веб-сервер, який буде читати великі двійкові файли (кілька мегабайт) у байтові масиви. Сервер міг би читати одночасно декілька файлів (різні запити на сторінці), тому я шукаю найбільш оптимізований спосіб зробити це без надто великого оподаткування процесора. Чи достатньо хороший код нижче?

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

Просто замініть всю справу на:

return File.ReadAllBytes(fileName);

Однак, якщо ви стурбовані витратою пам'яті, вам не слід читати весь файл в пам'ять всі відразу. Ви повинні це робити шматками.

Я можу стверджувати, що відповідь тут взагалі "не". Якщо вам абсолютно не потрібні всі дані одразу, подумайте про використання StreamAPI-інтерфейсу (або якогось варіанта зчитувача / ітератора). Це особливо важливо, коли у вас є кілька паралельних операцій (як це запропоновано запитанням), щоб мінімізувати завантаження системи та максимізувати пропускну здатність.

Наприклад, якщо ви передаєте дані поточному користувачеві:

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

Я б подумав так:

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

Ваш код може бути врахований до цього (замість 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;
} 

Зверніть увагу на Integer.MaxValue - обмеження розміру файлу, розміщене методом Read. Іншими словами, ви можете прочитати лише шматок 2 Гб одночасно.

Також зауважте, що останнім аргументом FileStream є розмір буфера.

Я б також запропонував прочитати про FileStream та BufferedStream .

Як завжди, найвигіднішою буде проста програма зразка, щоб отримати найшвидший профіль.

Також ваш базовий апарат матиме великий вплив на продуктивність. Ви використовуєте серверні диски на жорсткому диску з великими кешами та RAID-карту з вбудованим кешем пам'яті? Або ви використовуєте стандартний привід, підключений до порту IDE?

Залежно від частоти операцій, розміру файлів та кількості файлів, які ви переглядаєте, є інші проблеми з ефективністю, які слід враховувати. Варто пам’ятати, що кожен ваш байтовий масив буде випущений на волю сміттєзбірника. Якщо ви не кешуєте жодними з цих даних, ви можете створити багато сміття і втратити більшу частину своєї продуктивності, щоб % Час в GC. Якщо шматки перевищують 85 К, ви виділите на велику кучу об’єктів (LOH), яка потребує звільнення колекцій усіх поколінь (це дуже дорого, і на сервері буде припинено все виконання, поки воно триває ). Крім того, якщо у вас є багато об’єктів на LOH, ви можете закінчити фрагментацію LOH (LOH ніколи не ущільнюється), що призводить до низької продуктивності та винятків з пам'яті. Ви можете переробити процес, як тільки потрапите в певний момент, але я не знаю, чи це найкраща практика.

Справа в тому, що вам слід розглянути повний життєвий цикл вашої програми, перш ніж обов’язково просто прочитати всі байти в пам'яті якнайшвидшим способом, або ви можете торгувати короткостроковою продуктивністю для загальної продуктивності.

Я б сказав, BinaryReaderце добре, але його можна відновити замість усіх цих рядків коду для отримання довжини буфера:

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

Має бути краще, ніж використовувати .ReadAllBytes(), оскільки я побачив у коментарях до верхньої відповіді, що включає, .ReadAllBytes()що один із коментаторів мав проблеми з файлами> 600 Мб, оскільки a BinaryReaderпризначений для подібних речей. Крім того, внесення його у usingвиписку забезпечує FileStreamі BinaryReaderзакриття, і розпорядження.

У випадку, якщо "великий файл" мається на увазі понад 4 Гб, тоді моя наступна письмова логіка коду підходить. Основна проблема, яку слід помітити - це тип даних LONG, який використовується методом SEEK. Оскільки LONG здатний вказувати за межі 2 ^ 32 меж даних. У цьому прикладі код обробляє спочатку обробку великого файлу шматками в 1 Гб, після обробки великих цілих шматів 1 ГБ обробляються залишені (<1 ГБ) байти. Я використовую цей код для обчислення CRC файлів, що перевищують розмір 4 ГБ. (використовуючи https://crc32c.machinezoo.com/ для розрахунку crc32c у цьому прикладі)

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

Використовуйте клас BufferedStream в C # для підвищення продуктивності. Буфер - це блок байтів у пам'яті, який використовується для кешування даних, тим самим зменшуючи кількість викликів до операційної системи. Буфери покращують ефективність читання та запису.

Дивіться наступний приклад коду та додаткове пояснення: http://msdn.microsoft.com/en-us/library/system.io.bufferedstream.aspx

використовуй це:

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

Я рекомендую спробувати Response.TransferFile()метод, а потім Response.Flush()і Response.End()для обслуговування великих файлів.

Якщо ви маєте справу з файлами розміром понад 2 Гб, ви побачите, що вищевказані методи не працюють.

Набагато простіше просто передати потік в MD5 і дозволити, щоб фрагмент вашого файлу був для вас:

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