วิธีที่เร็วที่สุดในการอ่านไฟล์ข้อความแบบบรรทัดต่อบรรทัดคืออะไร

ฉันต้องการอ่านไฟล์ข้อความทีละบรรทัด ฉันต้องการทราบว่าฉันทำอย่างมีประสิทธิภาพมากที่สุดเท่าที่จะทำได้ภายในขอบเขต. NET C # ของสิ่งต่าง ๆ

นี่คือสิ่งที่ฉันพยายาม:

var filestream = new System.IO.FileStream(textFilePath,
                                          System.IO.FileMode.Open,
                                          System.IO.FileAccess.Read,
                                          System.IO.FileShare.ReadWrite);
var file = new System.IO.StreamReader(filestream, System.Text.Encoding.UTF8, true, 128);

while ((lineOfText = file.ReadLine()) != null)
{
    //Do something with the lineOfText
}

ในการหาวิธีที่รวดเร็วที่สุดในการอ่านไฟล์แต่ละบรรทัดคุณจะต้องทำการเปรียบเทียบ ฉันทำการทดสอบเล็กน้อยบนคอมพิวเตอร์ของฉันแล้ว แต่คุณไม่สามารถคาดหวังได้ว่าผลลัพธ์ของฉันจะนำไปใช้กับสภาพแวดล้อมของคุณ

ใช้ StreamReader.ReadLine

นี่เป็นวิธีการของคุณ ด้วยเหตุผลบางอย่างคุณตั้งค่าขนาดบัฟเฟอร์เป็นค่าที่น้อยที่สุด (128) การเพิ่มสิ่งนี้จะเป็นการเพิ่มประสิทธิภาพโดยทั่วไป ขนาดเริ่มต้นคือ 1,024 และตัวเลือกที่ดีอื่น ๆ คือ 512 (ขนาดเซกเตอร์ใน Windows) หรือ 4,096 (ขนาดคลัสเตอร์ใน NTFS) คุณจะต้องเรียกใช้เกณฑ์มาตรฐานเพื่อกำหนดขนาดบัฟเฟอร์ที่เหมาะสมที่สุด บัฟเฟอร์ที่ใหญ่กว่าคือ - ถ้าไม่เร็วกว่า - อย่างน้อยไม่ช้ากว่าบัฟเฟอร์ที่เล็กกว่า

const Int32 BufferSize = 128;
using (var fileStream = File.OpenRead(fileName))
  using (var streamReader = new StreamReader(fileStream, Encoding.UTF8, true, BufferSize)) {
    String line;
    while ((line = streamReader.ReadLine()) != null)
      // Process line
  }

FileStreamคอนสตรัคช่วยให้คุณระบุFileOptions FileOptions.SequentialScanตัวอย่างเช่นถ้าคุณกำลังอ่านไฟล์ขนาดใหญ่ตามลำดับตั้งแต่ต้นจนจบคุณอาจได้รับประโยชน์จาก การเปรียบเทียบเป็นสิ่งที่ดีที่สุดที่คุณสามารถทำได้

ใช้ไฟล์. ReadLines

นี่เป็นเหมือนโซลูชันของคุณเองยกเว้นว่าจะมีการใช้งานโดยใช้StreamReaderขนาดบัฟเฟอร์คงที่ 1,024 ในคอมพิวเตอร์ของฉันผลลัพธ์นี้มีประสิทธิภาพที่ดีขึ้นเล็กน้อยเมื่อเทียบกับรหัสของคุณด้วยขนาดบัฟเฟอร์ 128 อย่างไรก็ตามคุณสามารถเพิ่มประสิทธิภาพการทำงานเดียวกันโดยใช้ขนาดบัฟเฟอร์ที่ใหญ่ขึ้น วิธีนี้ถูกนำมาใช้โดยใช้บล็อกตัววนซ้ำและไม่ใช้หน่วยความจำสำหรับทุกบรรทัด

var lines = File.ReadLines(fileName);
foreach (var line in lines)
  // Process line

ใช้ File.ReadAllLines

นี่เป็นวิธีที่เหมือนกับวิธีก่อนหน้านี้ยกเว้นว่าวิธีนี้จะเพิ่มรายการของสตริงที่ใช้สร้างอาร์เรย์ที่ส่งคืนของบรรทัดดังนั้นความต้องการหน่วยความจำจึงสูงขึ้น อย่างไรก็ตามมันจะส่งคืนString[]และไม่ใช่การIEnumerable<String>อนุญาตให้คุณเข้าถึงบรรทัดแบบสุ่ม

var lines = File.ReadAllLines(fileName);
for (var i = 0; i < lines.Length; i += 1) {
  var line = lines[i];
  // Process line
}

ใช้ String.Split

วิธีนี้ช้ากว่าปกติมากอย่างน้อยในไฟล์ขนาดใหญ่ (ทดสอบในไฟล์ 511 KB) อาจเป็นเพราะวิธีString.Splitการใช้งาน นอกจากนี้ยังจัดสรรอาร์เรย์สำหรับทุกบรรทัดที่เพิ่มหน่วยความจำที่ต้องการเปรียบเทียบกับโซลูชันของคุณ

using (var streamReader = File.OpenText(fileName)) {
  var lines = streamReader.ReadToEnd().Split("\r\n".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
  foreach (var line in lines)
    // Process line
}

ข้อเสนอแนะของฉันคือการใช้File.ReadLinesเพราะมันสะอาดและมีประสิทธิภาพ หากคุณต้องการตัวเลือกการแชร์พิเศษ (ตัวอย่างเช่นคุณใช้FileShare.ReadWrite) คุณสามารถใช้รหัสของคุณเอง แต่คุณควรเพิ่มขนาดบัฟเฟอร์

หากคุณใช้. NET 4 เพียงใช้File.ReadLinesสิ่งที่ทำเพื่อคุณ ฉันสงสัยว่ามันเป็นมากเช่นเดียวกับคุณ แต่มันยังอาจจะใช้FileOptions.SequentialScanและกันชนขนาดใหญ่ (128 ดูเหมือนว่ามีขนาดเล็กมาก)

ในขณะที่File.ReadAllLines()เป็นหนึ่งในวิธีที่ง่ายที่สุดในการอ่านไฟล์ แต่ก็เป็นหนึ่งในวิธีที่ช้าที่สุด

หากคุณเพียงแค่ต้องการอ่านบรรทัดในไฟล์โดยไม่ต้องทำอะไรมากตามมาตรฐานเหล่านี้วิธีที่เร็วที่สุดในการอ่านไฟล์คือวิธีการแบบเก่าของ:

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

อย่างไรก็ตามหากคุณต้องทำมากกับแต่ละบรรทัดบทความนี้สรุปว่าวิธีที่ดีที่สุดคือต่อไปนี้ (และมันจะเร็วกว่าในการจัดสรรสตริงล่วงหน้า [] ถ้าคุณรู้ว่าคุณจะอ่านกี่บรรทัด):

AllLines = new string[MAX]; //only allocate memory here

using (StreamReader sr = File.OpenText(fileName))
{
        int x = 0;
        while (!sr.EndOfStream)
        {
               AllLines[x] = sr.ReadLine();
               x += 1;
        }
} //Finished. Close the file

//Now parallel process each line in the file
Parallel.For(0, AllLines.Length, x =>
{
    DoYourStuff(AllLines[x]); //do your work here
});

ใช้รหัสต่อไปนี้:

foreach (string line in File.ReadAllLines(fileName))

นี่คือความแตกต่างอย่างมากในประสิทธิภาพการอ่าน

มันมาพร้อมกับต้นทุนการใช้หน่วยความจำ แต่คุ้มค่าโดยสิ้นเชิง

มีหัวข้อที่ดีเกี่ยวกับเรื่องนี้ในคำถาม Stack Overflow คำถามคือ 'การคืนผลตอบแทน' ช้ากว่าการ "กลับไปโรงเรียนเก่า" หรือไม่ .

มันบอกว่า:

ReadAllLines โหลดบรรทัดทั้งหมดลงในหน่วยความจำและส่งคืนสตริง [] ทุกอย่างดีและดีถ้าไฟล์มีขนาดเล็ก หากไฟล์มีขนาดใหญ่กว่าจะพอดีกับหน่วยความจำคุณจะมีหน่วยความจำไม่เพียงพอ

ReadLines ในทางกลับกันใช้การคืนผลตอบแทนเพื่อกลับหนึ่งบรรทัดในแต่ละครั้ง ด้วยคุณสามารถอ่านไฟล์ขนาดใดก็ได้ มันไม่ได้โหลดไฟล์ทั้งหมดลงในหน่วยความจำ

สมมติว่าคุณต้องการค้นหาบรรทัดแรกที่มีคำว่า "foo" แล้วออก การใช้ ReadAllLines คุณจะต้องอ่านไฟล์ทั้งหมดในหน่วยความจำแม้ว่า "foo" จะเกิดขึ้นในบรรทัดแรก ด้วย ReadLines คุณจะอ่านเพียงหนึ่งบรรทัด อันไหนจะเร็วกว่ากัน?

หากขนาดไฟล์ไม่ใหญ่แสดงว่าเป็นการอ่านไฟล์ทั้งหมดที่เร็วกว่าและแยกไฟล์ในภายหลัง

var filestreams = sr.ReadToEnd().Split(Environment.NewLine, 
                              StringSplitOptions.RemoveEmptyEntries);

หากคุณมีหน่วยความจำเพียงพอฉันพบว่าประสิทธิภาพบางอย่างเพิ่มขึ้นโดยการอ่านไฟล์ทั้งหมดลงในสตรีมหน่วยความจำแล้วเปิดสตรีมตัวอ่านเพื่ออ่านบรรทัด ตราบใดที่คุณวางแผนที่จะอ่านไฟล์ทั้งหมดจริง ๆ แล้วสิ่งนี้สามารถปรับปรุงได้

คุณไม่สามารถทำงานได้เร็วขึ้นหากคุณต้องการใช้ API ที่มีอยู่เพื่ออ่านบรรทัด แต่การอ่านชิ้นที่ใหญ่ขึ้นและค้นหาแต่ละบรรทัดใหม่ในบัฟเฟอร์การอ่านอาจจะเร็วกว่า