C# Wie wird die Anzahl der Zeilen beim Lesen der Textdatei mit Stream Reader übersprungen?

Question

Ich habe ein Programm, das eine Textdatei liest und verarbeitet, um sie in Abschnitte zu trennen.

Die Frage ist also, wie kann das Programm geändert werden, damit das Programm das Lesen der ersten 5 Zeilen der Datei überspringen kann, während der Stream Reader zum Lesen der Datei verwendet wird?

Könnte jemand bitte auf die Codes hinweisen? Vielen Dank!

Die Codes:

class Program 
{ 
    static void Main(string[] args) 
    { 
     TextReader tr = new StreamReader(@"C:\Test\new.txt"); 

     String SplitBy = "----------------------------------------"; 

     // Skip first 5 lines of the text file? 
     String fullLog = tr.ReadToEnd(); 

     String[] sections = fullLog.Split(new string[] { SplitBy }, StringSplitOptions.None); 

     //String[] lines = sections.Skip(5).ToArray(); 

     foreach (String r in sections) 
     { 
      Console.WriteLine(r); 
      Console.WriteLine("============================================================"); 
     } 
    } 
} 

Answer 1

Versuchen die

// Skip 5 lines 
for(var i = 0; i < 5; i++) { 
    tr.ReadLine(); 
} 

// Read the rest 
string remainingText = tr.ReadToEnd(); 

Answer 2

folgenden Wenn die Linien dann fixiert sind der effizienteste Weg ist wie folgt:

using(Stream stream = File.Open(fileName, FileMode.Open)) 
{ 
    stream.Seek(bytesPerLine * (myLine - 1), SeekOrigin.Begin); 
    using(StreamReader reader = new StreamReader(stream)) 
    { 
     string line = reader.ReadLine(); 
    } 
} 

Und wenn die Linien variieren in der Länge müssen Sie sie dann in einer Linie auf einmal wie folgt lesen:

using (var sr = new StreamReader("file")) 
{ 
    for (int i = 1; i <= 5; ++i) 
     sr.ReadLine(); 
} 

Answer 3

Ich würde vermuten, es so einfach wie:

static void Main(string[] args) 
    { 
     var tr = new StreamReader(@"C:\new.txt"); 

     var SplitBy = "----------------------------------------"; 

     // Skip first 5 lines of the text file? 
     foreach (var i in Enumerable.Range(1, 5)) tr.ReadLine(); 
     var fullLog = tr.ReadToEnd(); 

     String[] sections = fullLog.Split(new string[] { SplitBy }, StringSplitOptions.None); 

     //String[] lines = sections.Skip(5).ToArray(); 

     foreach (String r in sections) 
     { 
      Console.WriteLine(r); 
      Console.WriteLine("============================================================"); 
     } 
    } 

Answer 4

Wenn Sie es mehrmals in Ihrem Programm verwenden mögen es dann vielleicht eine gute Idee, eine benutzerdefinierte Klasse von Stream mit der Fähigkeit geerbt machen Zeilen überspringen.

So etwas wie dies tun könnte:

class SkippableStreamReader : StreamReader 
{ 
    public SkippableStreamReader(string path) : base(path) { } 

    public void SkipLines(int linecount) 
    { 
     for (int i = 0; i < linecount; i++) 
     { 
      this.ReadLine(); 
     } 
    } 
} 

danach können Sie die Funktion des SkippableStreamReader verwenden Zeilen zu überspringen. Beispiel:

SkippableStreamReader exampleReader = new SkippableStreamReader("file_to_read"); 

//do stuff 
//and when needed 
exampleReader.SkipLines(number_of_lines_to_skip); 

Answer 5

Ich werde in die Liste zwei weitere Vorschläge hinzufügen.

Wenn es wird immer eine Datei sein, und Sie werden nur zu lesen sein, schlage ich folgende:

var lines = File.ReadLines(@"C:\Test\new.txt").Skip(5).ToArray(); 

File.ReadLines die Datei nicht von anderen nicht blockiert und nur in dem Speicher geladen notwendige Leitungen.

Wenn Strom aus anderen Quellen kommen dann schlage ich vor, diesen Ansatz:

class Program 
{ 
    static void Main(string[] args) 
    { 
     //it's up to you to get your stream 
     var stream = GetStream(); 

     //Here is where you'll read your lines. 
     //Any Linq statement can be used here. 
     var lines = ReadLines(stream).Skip(5).ToArray(); 

     //Go on and do whatever you want to do with your lines... 
    } 
} 

public IEnumerable<string> ReadLines(Stream stream) 
{ 
    using (var reader = new StreamReader(stream)) 
    { 
     while (!reader.EndOfStream) 
     { 
      yield return reader.ReadLine(); 
     } 
    } 
} 

Der Iteratorblock sich automatisch nach oben reinigen, sobald Sie damit fertig sind. Here ist ein Artikel von Jon Skeet, der genau beschreibt, wie das genau funktioniert (scrollen Sie nach unten zum Abschnitt "And finally ...").