C# Comment ignorer le nombre de lignes pendant la lecture d'un fichier texte en utilisant Stream Reader?

Question

J'ai un programme qui lit un fichier texte et le traite pour être séparé en sections. Donc, la question est de savoir comment changer le programme pour permettre au programme de sauter la lecture des 5 premières lignes du fichier tout en utilisant le lecteur de flux pour lire le fichier?

Pourriez-vous donner des conseils sur les codes? Merci!

Les 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

Effectuez les opérations suivantes

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

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

Answer 2

Si les lignes sont fixées alors la façon la plus efficace est la suivante:

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(); 
    } 
} 

Et si les lignes varient en longueur, alors vous devrez juste les lire dans une ligne à la fois comme suit:

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

Answer 3

Je suppose que c'est aussi simple que:

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

Si vous souhaitez utiliser plusieurs fois dans votre programme, alors il peut-être une bonne idée de faire une classe personnalisée héritée de StreamReader avec la capacité sauter des lignes.

Quelque chose comme cela pourrait faire:

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

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

après cela, vous pouvez utiliser la fonction de SkippableStreamReader sauter les lignes. Exemple:

SkippableStreamReader exampleReader = new SkippableStreamReader("file_to_read"); 

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

Answer 5

Je vais ajouter deux autres suggestions à la liste.

S'il y aura toujours un fichier, et vous ne serez lire, je suggère ceci:

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

File.ReadLines ne bloque pas le fichier des autres et des charges uniquement en mémoire les lignes nécessaires.

Si votre flux peut provenir d'autres sources alors je suggère que cette approche:

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(); 
     } 
    } 
} 

Le bloc itérateur se nettoyer automatiquement une fois que vous avez fini avec elle. Here est un article de Jon Skeet expliquant en détail comment cela fonctionne exactement (faites défiler jusqu'à la section "Et enfin ...").