C# 从包含超过10K个文件的目录中读取文件

我有一个包含多个子目录的目录，每个子目录都有超过10K的xml文件

当有1000个文件时，它通常在

5秒

内读取随机文件，而随着文件计数的增加，它需要超过

12秒

我使用以下代码检索文件内容：-

 if (File.Exists(xmlLogFilePath))
 {      
      string retrivedText = File.ReadAllText(xmlLogFilePath);     
 } 

是否有人能建议可以采取哪些措施来提高绩效

---

.Net版本：2.0

以下是一些可以考虑的方法：

考虑到文件量大，将数据移动到数据库

如果不可能，请尝试将硬盘升级到固态驱动器

或者，您可以将文件拆分到单独的磁盘上并并行读取

---

以下是一些可以考虑的方法：

考虑到文件量大，将数据移动到数据库

如果不可能，请尝试将硬盘升级到固态驱动器

或者，您可以将文件拆分到单独的磁盘上并并行读取

---

以下是一些可以考虑的方法：

考虑到文件量大，将数据移动到数据库

如果不可能，请尝试将硬盘升级到固态驱动器

或者，您可以将文件拆分到单独的磁盘上并并行读取

---

以下是一些可以考虑的方法：

考虑到文件量大，将数据移动到数据库

如果不可能，请尝试将硬盘升级到固态驱动器

或者，您可以将文件拆分到单独的磁盘上并并行读取

---

您可以使用并行异步I/O方法：

下面的示例通过编写10个文本文件来演示并行处理

public async void ProcessWriteMult()
{
    string folder = @"tempfolder\";
    List<Task> tasks = new List<Task>();
    List<FileStream> sourceStreams = new List<FileStream>();

    try
    {
        for (int index = 1; index <= 10; index++)
        {
            string text = "In file " + index.ToString() + "\r\n";

            string fileName = "thefile" + index.ToString("00") + ".txt";
            string filePath = folder + fileName;

            byte[] encodedText = Encoding.Unicode.GetBytes(text);

            FileStream sourceStream = new FileStream(filePath,
                FileMode.Append, FileAccess.Write, FileShare.None,
                bufferSize: 4096, useAsync: true);

            Task theTask = sourceStream.WriteAsync(encodedText, 0, encodedText.Length);
            sourceStreams.Add(sourceStream);

            tasks.Add(theTask);
        }

        await Task.WhenAll(tasks);
    }

    finally
    {
        foreach (FileStream sourceStream in sourceStreams)
        {
            sourceStream.Close();
        }
    }
}

public异步void ProcessWriteMult（）
{
字符串文件夹=@“tempfolder\”；
列表任务=新列表（）；
List sourceStreams=新列表（）；
尝试
{
对于（int index=1；index，您可以使用并行异步I/O方法：

下面的示例通过编写10个文本文件来演示并行处理

public async void ProcessWriteMult()
{
    string folder = @"tempfolder\";
    List<Task> tasks = new List<Task>();
    List<FileStream> sourceStreams = new List<FileStream>();

    try
    {
        for (int index = 1; index <= 10; index++)
        {
            string text = "In file " + index.ToString() + "\r\n";

            string fileName = "thefile" + index.ToString("00") + ".txt";
            string filePath = folder + fileName;

            byte[] encodedText = Encoding.Unicode.GetBytes(text);

            FileStream sourceStream = new FileStream(filePath,
                FileMode.Append, FileAccess.Write, FileShare.None,
                bufferSize: 4096, useAsync: true);

            Task theTask = sourceStream.WriteAsync(encodedText, 0, encodedText.Length);
            sourceStreams.Add(sourceStream);

            tasks.Add(theTask);
        }

        await Task.WhenAll(tasks);
    }

    finally
    {
        foreach (FileStream sourceStream in sourceStreams)
        {
            sourceStream.Close();
        }
    }
}

public异步void ProcessWriteMult（）
{
字符串文件夹=@“tempfolder\”；
列表任务=新列表（）；
List sourceStreams=新列表（）；
尝试
{
对于（int index=1；index，您可以使用并行异步I/O方法：

下面的示例通过编写10个文本文件来演示并行处理

public async void ProcessWriteMult()
{
    string folder = @"tempfolder\";
    List<Task> tasks = new List<Task>();
    List<FileStream> sourceStreams = new List<FileStream>();

    try
    {
        for (int index = 1; index <= 10; index++)
        {
            string text = "In file " + index.ToString() + "\r\n";

            string fileName = "thefile" + index.ToString("00") + ".txt";
            string filePath = folder + fileName;

            byte[] encodedText = Encoding.Unicode.GetBytes(text);

            FileStream sourceStream = new FileStream(filePath,
                FileMode.Append, FileAccess.Write, FileShare.None,
                bufferSize: 4096, useAsync: true);

            Task theTask = sourceStream.WriteAsync(encodedText, 0, encodedText.Length);
            sourceStreams.Add(sourceStream);

            tasks.Add(theTask);
        }

        await Task.WhenAll(tasks);
    }

    finally
    {
        foreach (FileStream sourceStream in sourceStreams)
        {
            sourceStream.Close();
        }
    }
}

public异步void ProcessWriteMult（）
{
字符串文件夹=@“tempfolder\”；
列表任务=新列表（）；
List sourceStreams=新列表（）；
尝试
{
对于（int index=1；index，您可以使用并行异步I/O方法：

下面的示例通过编写10个文本文件来演示并行处理

public async void ProcessWriteMult()
{
    string folder = @"tempfolder\";
    List<Task> tasks = new List<Task>();
    List<FileStream> sourceStreams = new List<FileStream>();

    try
    {
        for (int index = 1; index <= 10; index++)
        {
            string text = "In file " + index.ToString() + "\r\n";

            string fileName = "thefile" + index.ToString("00") + ".txt";
            string filePath = folder + fileName;

            byte[] encodedText = Encoding.Unicode.GetBytes(text);

            FileStream sourceStream = new FileStream(filePath,
                FileMode.Append, FileAccess.Write, FileShare.None,
                bufferSize: 4096, useAsync: true);

            Task theTask = sourceStream.WriteAsync(encodedText, 0, encodedText.Length);
            sourceStreams.Add(sourceStream);

            tasks.Add(theTask);
        }

        await Task.WhenAll(tasks);
    }

    finally
    {
        foreach (FileStream sourceStream in sourceStreams)
        {
            sourceStream.Close();
        }
    }
}

public异步void ProcessWriteMult（）
{
字符串文件夹=@“tempfolder\”；
列表任务=新列表（）；
List sourceStreams=新列表（）；
尝试
{
对于（int index=1；index而言，减速是由两个不同的因素造成的

首先，由于文件越来越多，它们总共会占用更多的空间。当您想读取“随机”文件时，它在磁盘缓存中的概率会降低。这将增加读取文件的平均时间，对此您无能为力，除了可能增加计算机中的RAM量

其次，目录是需要搜索文件的数据结构。随着目录的增加，即随着目录中文件数量的增加，这将花费更长的时间。您可以这样做：确保目录更小。例如，为所有文件创建一个目录，文件名以给定字符开头。这将l加快搜索速度。
速度减慢是由两个不同的因素造成的

首先，由于文件越来越多，它们总共会占用更多的空间。当您想读取“随机”文件时，它在磁盘缓存中的概率会降低。这将增加读取文件的平均时间，对此您无能为力，除了可能增加计算机中的RAM量

其次，目录是需要搜索文件的数据结构。随着目录的增加，即随着目录中文件数量的增加，这将花费更长的时间。您可以这样做：确保目录更小。例如，为所有文件创建一个目录，文件名以给定字符开头。这将l加快搜索速度。
速度减慢是由两个不同的因素造成的

首先，由于文件越来越多，它们总共会占用更多的空间。当您想读取“随机”文件时，它在磁盘缓存中的概率会降低。这将增加读取文件的平均时间，对此您无能为力，除了可能增加计算机中的RAM量

其次，目录是需要搜索文件的数据结构。随着目录的增加，即随着目录中文件数量的增加，这将花费更长的时间。您可以这样做：确保目录更小。例如，为所有文件创建一个目录，文件名以给定字符开头。这将l加快搜索速度。
速度减慢是由两个不同的因素造成的

首先，由于文件越来越多，它们总共会占用更多的空间。当您想读取“随机”文件时，它在磁盘缓存中的概率会降低。这将增加读取文件的平均时间，对此您无能为力，除了可能增加计算机中的RAM量

其次，目录是需要搜索文件的数据结构。随着目录的增加，即随着目录中文件数量的增加，这将花费更长的时间。您可以这样做：确保目录更小。例如，为所有文件创建一个目录，文件名以g开头