Cách tốt nhất để đọc một tệp lớn thành một mảng byte trong C #?

Tôi có một máy chủ web sẽ đọc các tệp nhị phân lớn (vài megabyte) thành các mảng byte. Máy chủ có thể đang đọc một số tệp cùng một lúc (các yêu cầu trang khác nhau), vì vậy tôi đang tìm cách tối ưu nhất để thực hiện việc này mà không đánh thuế CPU quá nhiều. Mã dưới đây có đủ tốt không?

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

Chỉ cần thay thế toàn bộ bằng:

return File.ReadAllBytes(fileName);

Tuy nhiên, nếu bạn lo lắng về mức tiêu thụ bộ nhớ, bạn không nên đọc toàn bộ tệp vào bộ nhớ cùng một lúc. Bạn nên làm điều đó trong khối.

Tôi có thể lập luận rằng câu trả lời ở đây nói chung là "không". Trừ khi bạn thực sự cần tất cả dữ liệu cùng một lúc, hãy xem xét sử dụng StreamAPI dựa trên (hoặc một số biến thể của trình đọc / trình lặp). Điều đó đặc biệt quan trọng khi bạn có nhiều hoạt động song song (như được đề xuất bởi câu hỏi) để giảm thiểu tải hệ thống và tối đa hóa thông lượng.

Ví dụ: nếu bạn đang truyền dữ liệu đến người gọi:

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

Tôi sẽ nghĩ điều này:

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

Mã của bạn có thể được xác định theo điều này (thay cho File.Read ALLBytes):

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

Lưu ý Integer.MaxValue - giới hạn kích thước tệp được đặt theo phương thức Đọc. Nói cách khác, bạn chỉ có thể đọc một đoạn 2 GB cùng một lúc.

Cũng lưu ý rằng đối số cuối cùng đối với FileStream là kích thước bộ đệm.

Tôi cũng sẽ đề nghị đọc về FileStream và BufferedStream .

Như mọi khi một chương trình mẫu đơn giản để hồ sơ nhanh nhất sẽ có lợi nhất.

Ngoài ra phần cứng cơ bản của bạn sẽ có ảnh hưởng lớn đến hiệu suất. Bạn có đang sử dụng ổ đĩa cứng dựa trên máy chủ với bộ nhớ cache lớn và thẻ RAID với bộ nhớ cache trên bo mạch không? Hay bạn đang sử dụng một ổ đĩa tiêu chuẩn được kết nối với cổng IDE?

Tùy thuộc vào tần suất hoạt động, kích thước của tệp và số lượng tệp bạn đang xem, có các vấn đề về hiệu suất khác cần xem xét. Một điều cần nhớ, là mỗi mảng byte của bạn sẽ được phát hành trong sự thương xót của trình thu gom rác. Nếu bạn không lưu trữ bất kỳ dữ liệu nào trong số đó, cuối cùng bạn có thể tạo ra rất nhiều rác và sẽ mất phần lớn hiệu suất của mình xuống % Time trong GC. Nếu các khối lớn hơn 85K, bạn sẽ phân bổ cho Heap đối tượng lớn (LOH) sẽ yêu cầu một bộ sưu tập của tất cả các thế hệ để giải phóng (điều này rất tốn kém và trên máy chủ sẽ dừng tất cả thực thi trong khi nó đang diễn ra ). Ngoài ra, nếu bạn có rất nhiều đối tượng trên LOH, bạn có thể bị phân mảnh LOH (LOH không bao giờ được nén) dẫn đến hiệu suất kém và ngoại lệ bộ nhớ. Bạn có thể tái chế quy trình một khi bạn đạt đến một điểm nhất định, nhưng tôi không biết liệu đó có phải là cách thực hành tốt nhất không.

Vấn đề là, bạn nên xem xét toàn bộ vòng đời của ứng dụng trước khi chỉ cần đọc tất cả các byte vào bộ nhớ theo cách nhanh nhất có thể hoặc bạn có thể giao dịch hiệu suất ngắn hạn để có hiệu suất tổng thể.

Tôi muốn nói BinaryReaderlà ổn, nhưng có thể được tái cấu trúc cho điều này, thay vì tất cả các dòng mã để lấy độ dài của bộ đệm:

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

Nên sử dụng tốt hơn .ReadAllBytes(), vì tôi đã thấy trong các nhận xét về phản hồi hàng đầu bao gồm .ReadAllBytes()một trong những người bình luận có vấn đề với các tệp> 600 MB, vì BinaryReaderý nghĩa của việc này là như vậy. Ngoài ra, đưa nó vào một usingtuyên bố đảm bảo FileStreamvà BinaryReaderđược đóng và xử lý.

Trong trường hợp với 'một tệp lớn' có nghĩa là vượt quá giới hạn 4GB, thì logic mã bằng văn bản sau đây của tôi là phù hợp. Vấn đề chính cần chú ý là kiểu dữ liệu LONG được sử dụng với phương thức XEM. Là một LONG có thể chỉ ra ngoài 2 ^ 32 ranh giới dữ liệu. Trong ví dụ này, mã đang xử lý trước tiên xử lý tệp lớn trong các khối 1GB, sau khi toàn bộ khối 1GB lớn được xử lý, các byte còn lại (<1GB) được xử lý. Tôi sử dụng mã này với tính toán CRC của các tệp vượt quá kích thước 4GB. (sử dụng https://crc32c.machinezoo.com/ để tính toán crc32c trong ví dụ này)

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

Sử dụng lớp BufferedStream trong C # để cải thiện hiệu suất. Bộ đệm là một khối byte trong bộ nhớ được sử dụng để lưu trữ dữ liệu, do đó giảm số lượng cuộc gọi đến hệ điều hành. Bộ đệm cải thiện hiệu suất đọc và viết.

Xem phần sau đây để biết ví dụ về mã và giải thích bổ sung: http://msdn.microsoft.com/en-us/l Library / system.io.bufferedstream.aspx

dùng cái này:

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

Tổng quan: nếu hình ảnh của bạn được thêm dưới dạng hành động = tài nguyên được nhúng thì hãy sử dụng GetExecutingAssugging để truy xuất tài nguyên jpg vào luồng sau đó đọc dữ liệu nhị phân trong luồng vào một mảng byte

   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;

    }

Tôi khuyên bạn nên thử Response.TransferFile()phương pháp sau đó Response.Flush()và Response.End()để phục vụ các tệp lớn của bạn.

Nếu bạn đang xử lý các tệp trên 2 GB, bạn sẽ thấy rằng các phương pháp trên không thành công.

Việc chuyển luồng sang MD5 sẽ dễ dàng hơn nhiều và cho phép điều đó giúp phân chia tệp của bạn cho bạn:

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