Die Methode zum Lesen des Inhalts einer oder mehrerer Dateien.
In C# können Sie die File.ReadAllLines-Methode verwenden, um den gesamten Zeileninhalt in mehreren Dateien gleichzeitig zu lesen. Der folgende Code liest beispielsweise alle Zeilen aus zwei Dateien und führt sie zusammen:
string[] file1Lines = File.ReadAllLines("file1.txt");
string[] file2Lines = File.ReadAllLines("file2.txt");
string[] allLines = file1Lines.Concat(file2Lines).ToArray();
Der obige Code verwendet zunächst die Methode File.ReadAllLines, um alle Zeileninhalte in file1.txt bzw. file2.txt zu lesen und sie in zwei verschiedenen String-Arrays zu speichern. Verwenden Sie dann die Concat-Methode von LINQ, um diese Arrays zu einem neuen String-Array zu kombinieren. Verwenden Sie abschließend die ToArray-Methode, um IEnumerable in einen String[]-Array-Typ zu konvertieren.
Den Inhalt Tausender Dateien gleichzeitig lesen
Wenn Sie den Inhalt Tausender Dateien gleichzeitig lesen möchten, können Sie die Lesegeschwindigkeit mit der Methode Parallel.ForEach erhöhen. Die Parallel.ForEach-Methode ermöglicht die parallele Verarbeitung von Elementen in einer Sammlung.
Hier ist ein Beispielcode, der zeigt, wie man Parallel.ForEach verwendet, um den Inhalt von Tausenden von Dateien zu lesen:
string[] fileNames = Directory.GetFiles(@"C:\files\"); // 获取要读取的文件列表
ConcurrentBag<string> allLines = new ConcurrentBag<string>();
Parallel.ForEach(fileNames, fileName =>
{
string[] fileLines = File.ReadAllLines(fileName);
foreach (string line in fileLines)
{
allLines.Add(line);
}
});
// 在这里对所有行进行处理
foreach (string line in allLines)
{
// 处理逻辑
}
Der obige Code verwendet zunächst die Methode Directory.GetFiles, um alle Dateien im Verzeichnis abzurufen. Übergeben Sie dann die Liste der Dateinamen an die Parallel.ForEach-Methode, um jede Datei parallel zu verarbeiten. Lesen Sie bei der Verarbeitung jeder Datei den Inhalt aller Zeilen mit der File.ReadAllLines-Methode und verwenden Sie einen ConcurrentBag, um den Inhalt aller Zeilen sicher zu speichern. Schließlich können alle Zeileninhalte in einer Schleife verarbeitet werden.
Durch die Verwendung der Parallel.ForEach-Methode können Multi-Core-Prozessoren effektiv genutzt und das Lesen von Dateien beschleunigt werden. Es ist jedoch zu beachten, dass Multithreading einen gewissen Overhead mit sich bringt. Wenn die Datei klein ist, verringert die Aktivierung von Multithreading tatsächlich die Lesegeschwindigkeit. Daher ist es auch notwendig, je nach Situation und Szene bei der spezifischen Verwendung eine Auswahl zu treffen.
Lesen Sie den Inhalt von Zehntausenden Dateien gleichzeitig, ohne viele Ressourcen zu beanspruchen.
Wenn Sie den Inhalt von Zehntausenden Dateien gleichzeitig lesen müssen, ohne viele Ressourcen zu beanspruchen, können Sie Stream Processing zum Lesen der Dateien verwenden. Das heißt, lesen Sie jeweils nur einen Teil des Inhalts und lesen Sie dann den nächsten Teil weiter, nachdem Sie diesen Teil des Inhalts verarbeitet haben. Dadurch wird vermieden, dass der gesamte Dateiinhalt auf einmal in den Speicher eingelesen wird, wodurch die Speichernutzung reduziert wird.
Im Folgenden finden Sie einen Beispielcode, der zeigt, wie Zehntausende Dateien mithilfe von Streaming gelesen werden:
string[] fileNames = Directory.GetFiles(@"C:\files\");
foreach (string fileName in fileNames)
{
using (StreamReader reader = new StreamReader(fileName))
{
string line;
while ((line = reader.ReadLine()) != null)
{
// 在这里处理每一行的内容
}
}
}
Der obige Code ruft zunächst alle Dateien im Verzeichnis ab und durchläuft dann jede Datei mithilfe einer foreach-Schleife. Verwenden Sie in jeder Datei die ReadLine-Methode von StreamReader, um den Inhalt der Datei Zeile für Zeile zu lesen, bis das Ende der Datei gelesen ist. Nachdem jede Inhaltszeile gelesen wurde, kann jede Inhaltszeile in einer Schleife verarbeitet werden.
Diese Methode kann dazu führen, dass das Programm beim Lesen der Datei nicht gleichzeitig viel Speicher belegt und sie Zeile für Zeile Schritt für Schritt liest, um den Speicher freizugeben. Diese Methode kann jedoch mehr Zeit in Anspruch nehmen als das gleichzeitige Lesen und erneute Verarbeiten.
Lesen Sie den Inhalt von Zehntausenden Dateien gleichzeitig, ohne viel Ressourcen zu beanspruchen und mit hoher Geschwindigkeit.
Wenn Sie Zehntausende Dateien gleichzeitig lesen möchten, ohne viel Speicher zu beanspruchen, und mit höherer Geschwindigkeit, dann sind Sie hier genau richtig kann parallele Verarbeitung nutzen. Die Dateien werden zur Verarbeitung verschiedenen Threads zugewiesen. Gleichzeitig sollte die Stream-Verarbeitung auch dazu verwendet werden, nur einen Teil des Inhalts zu lesen, um zu vermeiden, dass gleichzeitig viel Speicher belegt wird.
Hier ist ein Beispielcode, der zeigt, wie Zehntausende Dateien gleichzeitig mithilfe von Parallelverarbeitung und Streaming gelesen werden können:
string[] fileNames = Directory.GetFiles(@"C:\files\");
Parallel.ForEach(fileNames, fileName =>
{
using (StreamReader reader = new StreamReader(fileName))
{
string line;
while ((line = reader.ReadLine()) != null)
{
// 在这里处理每一行的内容
}
}
});
Der obige Code verwendet die Parallel.ForEach-Methode, um verschiedene Dateien verschiedenen Threads zur Verarbeitung zuzuweisen und so Dateien parallel zu verarbeiten. Verwenden Sie in jedem Thread die ReadLine-Methode von StreamReader, um den Inhalt der Datei Zeile für Zeile zu lesen, um zu vermeiden, dass gleichzeitig viel Speicher belegt wird, und verarbeiten Sie jede Inhaltszeile, nachdem der Inhalt jeder Zeile verarbeitet wurde.
Durch die Verwendung der Parallelverarbeitung kann die Nutzung von Mehrkernprozessoren maximiert und dadurch die Geschwindigkeit beim Lesen von Dateien erhöht werden. Gleichzeitig kann durch die Verwendung der Stream-Verarbeitung vermieden werden, dass viel Speicher gleichzeitig belegt wird, sodass nicht nur eine große Anzahl von Dateien schnell verarbeitet werden kann, sondern auch sichergestellt wird, dass das Programm aufgrund der großen Menge an Dateien nicht abstürzt Speicher belegt.
Der Unterschied zwischen Parallel.ForEach und ThreadPool zum Erstellen und Verwalten von Threads
Sowohl Parallel.ForEach als auch ThreadPool in C# sind Technologien für die Multithread-Programmierung, es gibt jedoch einige wesentliche Unterschiede zwischen den beiden. Die Hauptunterschiede sind wie folgt:
Verwendung: Parallel.ForEach wird im Allgemeinen zum parallelen Verarbeiten von Elementen in einer Sammlung verwendet, während ThreadPool zum Verwalten von Thread-Pools und zum Ausführen einiger relativ einfacher gleichzeitiger Aufgaben verwendet wird.
Kontrollgranularität: In Parallel.ForEach ist die Grundeinheit zur Steuerung der Anzahl von Thread-Aufrufen das Element in der Sammlung; in ThreadPool ist die Einheit die Aufgabe.
Explizitheit: Parallel.ForEach ist eine Methode zum expliziten Erstellen von Threads, die direkt im Code verwendet werden kann, der eine gleichzeitige Verarbeitung ohne weitere Zusammenarbeit erfordert; während ThreadPool in Form eines Thread-Pools im System vorhanden ist und benötigt Der Aufrufer übergibt bestimmte Aufgaben zur Ausführung an den Thread-Pool übergeben.
Thread-Lebenszyklus: Parallel.ForEach erstellt und recycelt Threads während des Ausführungsprozesses. Wenn die Methode in ForEach ausgeführt wird, wird der Thread freigegeben: während ThreadPool die Threads während der Ausführung des Programms im Thread-Pool verwaltet. Auch wenn Diese Threads haben keine Aufgaben. Werden auch nicht freigegeben, immer auf Abruf.
Betriebssteuerung: Parallel.ForEach kann die Vorgänge in der Schleife direkter steuern, während ThreadPool einige Mittel verwenden muss, um die bei gleichzeitigen Vorgängen erzeugten Konflikte zu steuern.
Kurz gesagt, Parallel.ForEach und ThreadPool haben jeweils ihre eigenen Vor- und Nachteile. Bei verschiedenen gleichzeitigen Aufgaben müssen Entwickler Faktoren wie Nutzungseffekte und Leistung entsprechend der tatsächlichen Situation umfassend berücksichtigen und eine Wahl treffen.
Hier zwei Beispiele:
Verwenden Sie Parallel.ForEach:
List<int> numbers = Enumerable.Range(0, 1000000).ToList();
Parallel.ForEach(numbers, number =>
{
int result = SomeExpensiveCalculation(number);
Console.WriteLine(result);
});
Verwenden Sie ThreadPool:
List<int> numbers = Enumerable.Range(0, 1000000).ToList();
foreach (int number in numbers)
{
ThreadPool.QueueUserWorkItem(state =>
{
int result = SomeExpensiveCalculation(number);
Console.WriteLine(result);
});
}
Die obigen Codes veranschaulichen, wie man Parallel.ForEach und ThreadPool verwendet, um eine Liste von 1.000.000 Elementen gleichzeitig zu verarbeiten und jeweils aufwendige Berechnungen für jedes Element durchzuführen. Wenn Sie Parallel.ForEach verwenden, können Sie eine Liste direkt an die ForEach-Methode übergeben und Berechnungen für jedes Element durchführen. Wenn Sie ThreadPool verwenden, müssen Sie die Aufgabe in der ThreadPool.QueueUserWorkItem-Methode kapseln und die Aufgabe zur Ausführung zum Thread-Pool hinzufügen.