在 C# 中使用流读取大文本文件

Question

我有一项可爱的任务，就是研究如何处理加载到应用程序脚本编辑器中的大文件（就像 VBA 用于我们用于快速宏的内部产品）。大多数文件约为 300-400 KB，可以很好地加载。但是当它们超过 100 MB 时，该过程就会变得困难（正如您所期望的那样）。

发生的情况是，文件被读取并推入 RichTextBox，然后进行导航 - 不要太担心这部分。

编写初始代码的开发人员只是使用 StreamReader，

[Reader].ReadToEnd()

这可能需要相当长的时间才能完成。

我的任务是分解这段代码，将其分块读入缓冲区，并显示一个带有取消它的选项的进度条。

一些假设：

• 大多数文件为 30-40MB
• 文件内容是文本（不是二进制），有些是 Unix 格式，有些是 DOS 格式。
• 一旦检索到内容，我们就可以确定使用的终止符。
• 加载后，没有人会担心在 Richtextbox 中渲染所需的时间。这只是文本的初始负载。

现在的问题是：

• 我可以简单地使用 StreamReader，然后检查 Length 属性（因此 ProgressMax）并针对设置的缓冲区大小发出 Read 并在后台工作程序内的 while 循环中进行迭代，所以它不会阻塞主 UI 线程吗？然后在完成后将字符串构建器返回到主线程。
• 内容将进入 StringBuilder。如果长度可用，我可以用流的大小初始化 StringBuilder 吗？

这些（以您的专业观点）是好主意吗？过去，我在从 Streams 读取内容时遇到了一些问题，因为它总是会丢失最后几个字节或其他内容，但如果是这种情况，我会问另一个问题。

Answer 1

您可以通过使用 BufferedStream 来提高读取速度，如下所示：

using (FileStream fs = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
using (BufferedStream bs = new BufferedStream(fs))
using (StreamReader sr = new StreamReader(bs))
{
    string line;
    while ((line = sr.ReadLine()) != null)
    {

    }
}

2013 年 3 月更新

我最近编写了用于读取和处理（在其中搜索文本）1 GB 左右的文本文件（比文件大得多）的代码此处涉及）并通过使用生产者/消费者模式实现了显着的性能提升。生产者任务使用 BufferedStream 读取文本行，并将它们交给执行搜索的单独消费者任务。

我以此为契机学习 TPL Dataflow，它非常适合快速编码此模式。

为什么 BufferedStream 更快

缓冲区是内存中用于缓存数据的字节块，从而减少对操作系统的调用次数。缓冲区可提高读写性能。缓冲区可用于读取或写入，但不能同时用于两者。 BufferedStream 的 Read 和 Write 方法自动维护缓冲区。

2014 年 12 月更新：您的情况可能会有所不同

根据评论，FileStream 应该使用 BufferedStream 内部。在第一次提供这个答案时，我通过添加 BufferedStream 测量到了显着的性能提升。当时我的目标是 32 位平台上的 .NET 3.x。今天，针对 64 位平台上的 .NET 4.5，我没有看到任何改进。

相关

我遇到过一种情况，将生成的大型 CSV 文件从 ASP.Net MVC 操作流式传输到响应流非常慢。在本例中，添加 BufferedStream 将性能提高了 100 倍。有关详细信息，请参阅无缓冲输出非常慢

Answer 2

如果您阅读了本网站上的性能和基准统计数据，您将看到读取（因为读取、写入和处理都不同）文本文件的最快方法是以下代码片段：

using (StreamReader sr = File.OpenText(fileName))
{
    string s = String.Empty;
    while ((s = sr.ReadLine()) != null)
    {
        //do your stuff here
    }
}

总共大约有 9 种不同的方法标记，但大多数情况下，它似乎都领先，甚至像其他读者提到的那样，比执行缓冲读取器还要好。

Answer 3

您说您被要求在加载大文件时显示进度条。这是因为用户真的想看到文件加载的确切百分比，还是只是因为他们想要看到正在发生的事情的视觉反馈？

如果后者为真，那么解决方案就会变得简单得多。只需在后台线程上执行reader.ReadToEnd()，并显示一个选取框类型的进度条而不是正确的进度条。

我提出这一点是因为根据我的经验，这种情况经常发生。当你在编写数据处理程序时，那么用户肯定会对百分比完整的数字感兴趣，但对于简单但缓慢的 UI 更新，他们更有可能只想知道计算机有没有崩溃。 :-)

Answer 4

使用后台工作者并只读取有限数量的行。仅当用户滚动时才能阅读更多内容。

并尽量不要使用 ReadToEnd()。这是您认为“他们为什么要这样做？”的功能之一；它是一个脚本小子助手，可以很好地处理小事情，但正如你所见，它很糟糕大文件...

那些告诉您使用 StringBuilder 的人需要更频繁地阅读 MSDN：

性能注意事项
Concat 和 AppendFormat 方法都将新数据连接到现有 String 或 StringBuilder 对象。 String 对象串联操作始终从现有字符串和新数据创建一个新对象。 StringBuilder 对象维护一个缓冲区来容纳新数据的串联。如果有可用空间，新数据将附加到缓冲区末尾；否则，分配一个新的、更大的缓冲区，将原始缓冲区中的数据复制到新缓冲区，然后将新数据附加到新缓冲区。
String 或 StringBuilder 对象的串联操作的性能取决于内存分配发生的频率。
String 串联操作始终分配内存，而 StringBuilder 串联操作仅在 StringBuilder 对象缓冲区太小而无法容纳新数据时才分配内存。因此，如果连接固定数量的 String 对象，则 String 类更适合连接操作。在这种情况下，编译器甚至可能将各个串联操作组合成单个操作。如果连接任意数量的字符串，则 StringBuilder 对象更适合连接操作；例如，如果循环连接随机数量的用户输入字符串。

这意味着大量内存分配，这会导致大量使用交换文件系统，模拟硬盘的各个部分驱动器的作用类似于 RAM 内存，但硬盘驱动器的速度非常慢。

对于以单用户身份使用系统的人来说，StringBuilder 选项看起来不错，但是当有两个或更多用户同时读取大文件时，就会遇到问题。

Answer 5

对于二进制文件，我发现的最快的读取它们的方法是这样的。

 MemoryMappedFile mmf = MemoryMappedFile.CreateFromFile(file);
 MemoryMappedViewStream mms = mmf.CreateViewStream();
 using (BinaryReader b = new BinaryReader(mms))
 {
 }

在我的测试中，速度快了数百倍。

Answer 6

这应该足以让您开始。

class Program
{        
    static void Main(String[] args)
    {
        const int bufferSize = 1024;

        var sb = new StringBuilder();
        var buffer = new Char[bufferSize];
        var length = 0L;
        var totalRead = 0L;
        var count = bufferSize; 

        using (var sr = new StreamReader(@"C:\Temp\file.txt"))
        {
            length = sr.BaseStream.Length;               
            while (count > 0)
            {                    
                count = sr.Read(buffer, 0, bufferSize);
                sb.Append(buffer, 0, count);
                totalRead += count;
            }                
        }

        Console.ReadKey();
    }
}

Answer 7

看看下面的代码片段。您提到过大多数文件大小为 30-40 MB。声称在 Intel 四核处理器上可在 1.4 秒内读取 180 MB：

private int _bufferSize = 16384;

private void ReadFile(string filename)
{
    StringBuilder stringBuilder = new StringBuilder();
    FileStream fileStream = new FileStream(filename, FileMode.Open, FileAccess.Read);

    using (StreamReader streamReader = new StreamReader(fileStream))
    {
        char[] fileContents = new char[_bufferSize];
        int charsRead = streamReader.Read(fileContents, 0, _bufferSize);

        // Can't do much with 0 bytes
        if (charsRead == 0)
            throw new Exception("File is 0 bytes");

        while (charsRead > 0)
        {
            stringBuilder.Append(fileContents);
            charsRead = streamReader.Read(fileContents, 0, _bufferSize);
        }
    }
}

原创文章

Answer 8

所有优秀的答案！然而，对于寻找答案的人来说，这些似乎有些不完整。

由于标准字符串只能为 X 大小、2Gb 到 4Gb，具体取决于您的配置，这些答案并不能真正满足 OP 的问题。一种方法是使用字符串列表：

List<string> Words = new List<string>();

using (StreamReader sr = new StreamReader(@"C:\Temp\file.txt"))
{

string line = string.Empty;

while ((line = sr.ReadLine()) != null)
{
    Words.Add(line);
}
}

有些人可能希望在处理时对行进行标记和分割。字符串列表现在可以包含大量文本。

Answer 9

虽然获得最多支持的答案是正确的，但它缺乏多核处理的使用。就我而言，我使用 PLink 有 12 个核心：

Parallel.ForEach(
    File.ReadLines(filename), //returns IEumberable<string>: lazy-loading
    new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount },
    (line, state, index) =>
    {
        //process line value
    }
);

值得一提的是，我在面试时遇到了一个问题，要求返回出现次数最多的 10 个：

var result = new ConcurrentDictionary<string, int>(StringComparer.InvariantCultureIgnoreCase);
Parallel.ForEach(
    File.ReadLines(filename),
    new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount },
    (line, state, index) =>
    {
        result.AddOrUpdate(line, 1, (key, val) => val + 1);        
    }
);

return result
    .OrderByDescending(x => x.Value)
    .Take(10)
    .Select(x => x.Value);

基准测试：
BenchmarkDotNet=v0.12.1，操作系统=Windows 10.0.19042
Intel Core i7-8700K CPU 3.70GHz (Coffee Lake)，1 个 CPU，12 个逻辑核心和 6 个物理核心
[主机]：.NET Framework 4.8 (4.8.4250.0)、X64 RyuJIT
默认作业：.NET Framework 4.8 (4.8.4250.0)、X64 RyuJIT
。

方法	平均	误差	StdDev	Gen 0	Gen 1	Gen 2	已分配
GetTopWordsSync	33.03 s	0.175 s	0.155 s	1194000	314000	7000	7.06 GB
GetTopWordsParallel	10.89 s	0.121 s	0.113 s	1225000	354000	8000	7.18 GB

正如您所看到的，性能提高了 75%

但请注意，7Gb 会立即加载到内存中，并且由于它是一个 blob，因此会给 GC 带来太大的压力。

Answer 10

您可能最好使用内存映射文件处理此处。内存映射文件支持将存在于 .NET 4 中（我想...我通过其他人谈论它听说过），因此这个包装器使用 p/invokes 来完成相同的工作。.

编辑：请参阅此处MSDN 了解其工作原理，这里是 博客条目指示在即将发布的 .NET 4 发布时如何完成该操作。我之前给出的链接是 pinvoke 的包装器，以实现此目的。您可以将整个文件映射到内存中，并在滚动文件时像滑动窗口一样查看它。

Answer 11

距离上次回答已经过去了 10 多年，这是我的解决方案，用于读取超过 10Gb 的文本文件并按照您所需的长度返回结果。放在这里以防有人寻求帮助:)

public static List<string> ReadFileNGetLine(string filepath, int lenghtLine)
    {
        List<string> listString = new List<string>();
        try
        {
            StringBuilder resultAsString = new StringBuilder();

            FileInfo info = new FileInfo(filepath);
            if (info.Length < 10)
            {
                return listString;
            }
            using (MemoryMappedFile memoryMappedFile = MemoryMappedFile.CreateFromFile(filepath))
            using (MemoryMappedViewStream memoryMappedViewStream = memoryMappedFile.CreateViewStream(0, info.Length))
            {
                for (int i = 0; i < info.Length; i++)
                {
                    //Reads a byte from a stream and advances the position within the stream by one byte, or returns -1 if at the end of the stream.
                    if (listString.Count() >= lenghtLine)
                    {
                        break;
                    }
                    int result = memoryMappedViewStream.ReadByte();

                    if (result == -1)
                    {
                        break;
                    }

                    char letter = (char)result;
                    //khang: checking if the end of line is break line to collect full line
                    if ((letter.ToString() == "\r" || letter.ToString() == "\n") && letter.ToString() != "")
                    {
                        if (letter.ToString() != "\r")
                        {
                            listString.Add(resultAsString.ToString());
                            resultAsString.Clear();
                        }

                    }
                    else
                    {
                        resultAsString.Append(letter);
                    }

                }
            }
        }
        catch (Exception ex)
        {
            throw;
        }
        return listString;
    }

Answer 12

迭代器可能非常适合此类工作：

public static IEnumerable<int> LoadFileWithProgress(string filename, StringBuilder stringData)
{
    const int charBufferSize = 4096;
    using (FileStream fs = File.OpenRead(filename))
    {
        using (BinaryReader br = new BinaryReader(fs))
        {
            long length = fs.Length;
            int numberOfChunks = Convert.ToInt32((length / charBufferSize)) + 1;
            double iter = 100 / Convert.ToDouble(numberOfChunks);
            double currentIter = 0;
            yield return Convert.ToInt32(currentIter);
            while (true)
            {
                char[] buffer = br.ReadChars(charBufferSize);
                if (buffer.Length == 0) break;
                stringData.Append(buffer);
                currentIter += iter;
                yield return Convert.ToInt32(currentIter);
            }
        }
    }
}

您可以使用以下方式调用它：

string filename = "C:\\myfile.txt";
StringBuilder sb = new StringBuilder();
foreach (int progress in LoadFileWithProgress(filename, sb))
{
    // Update your progress counter here!
}
string fileData = sb.ToString();

加载文件时，迭代器将返回从 0 到 100 的进度数字，您可以使用它来更新进度栏。循环完成后，StringBuilder 将包含文本文件的内容。

另外，因为您需要文本，我们可以使用 BinaryReader 读取字符，这将确保您的缓冲区在读取任何多字节字符时正确排列（UTF-8, UTF- 16等）。

这一切都是在不使用后台任务、线程或复杂的自定义状态机的情况下完成的。

Answer 13

我的文件超过 13 GB：

下面的链接包含轻松读取一段文件的代码：

读取一个大文本文件

更多信息