Lecture d'un fichier ligne par ligne en C#

Je suis en train de lire des fichiers texte où chaque ligne doit être traité. Pour le moment je suis juste en utilisant un StreamReader, et puis à la lecture de chaque ligne individuellement.

Je me demande si il existe un moyen plus efficace (en termes de LoC et la lisibilité) pour ce faire à l'aide de LINQ sans compromettre l'efficacité opérationnelle. Les exemples que j'ai vu impliquer le chargement de tout le fichier en mémoire, puis de les traiter. Cependant dans ce cas, je ne crois pas que ce serait très efficace. Dans le premier exemple, les fichiers peuvent obtenir jusqu'à environ 50k, et dans le deuxième exemple, toutes les lignes du fichier doit être lu (les tailles sont généralement de < 10k).

On pourrait dire que, de nos jours, il n'a pas vraiment d'importance pour ces petits fichiers, mais je crois que sorte de l'approche conduit à l'inefficacité de code.

Premier exemple:

//Open file
using(var file = System.IO.File.OpenText(_LstFilename))
{
    //Read file
    while (!file.EndOfStream)
    {
        String line = file.ReadLine();

        //Ignore empty lines
        if (line.Length > 0)
        {
            //Create addon
            T addon = new T();
            addon.Load(line, _BaseDir);

            //Add to collection
            collection.Add(addon);
        }
    }
}

Deuxième exemple:

//Open file
using (var file = System.IO.File.OpenText(datFile))
{
    //Compile regexs
    Regex nameRegex = new Regex("IDENTIFY (.*)");

    while (!file.EndOfStream)
    {
        String line = file.ReadLine();

        //Check name
        Match m = nameRegex.Match(line);
        if (m.Success)
        {
            _Name = m.Groups[1].Value;

            //Remove me when other values are read
            break;
        }
    }
}

50K n'est même pas assez grand pour le faire dans le tas d'objets volumineux. Streaming de sens que si vos fichiers sont dans le mégaoctet (ou plus) de la gamme, pas de kilo-octets.

InformationsquelleAutor Luca Spiller | 2009-08-13

c#line linq

94

Vous pouvez écrire un LINQ ligne basée sur le lecteur assez facilement à l'aide d'un itérateur bloc:
```
static IEnumerable<SomeType> ReadFrom(string file) {
    string line;
    using(var reader = File.OpenText(file)) {
        while((line = reader.ReadLine()) != null) {
            SomeType newRecord = /* parse line */
            yield return newRecord;
        }
    }
}
```
ou de faire de Jon heureux:
```
static IEnumerable<string> ReadFrom(string file) {
    string line;
    using(var reader = File.OpenText(file)) {
        while((line = reader.ReadLine()) != null) {
            yield return line;
        }
    }
}
...
var typedSequence = from line in ReadFrom(path)
                    let record = ParseLine(line)
                    where record.Active //for example
                    select record.Key;
```
alors vous avez ReadFrom(...) comme un paresseusement évalué séquence sans mise en mémoire tampon, parfait pour Where etc.

Notez que si vous utilisez OrderBy ou de la norme GroupBy, il va avoir de la mémoire tampon les données dans la mémoire; si vous besoin de regroupement et d'agrégation, "PushLINQ" a peu de fantaisie de code pour vous permettre d'effectuer des agrégations sur les données, mais de les jeter (pas de tampon). Jon explication est ici.
- Bah, la séparation des préoccupations séparée de la ligne de lecture dans un itérateur, et l'utilisation normale de projection 🙂
- Beaucoup plus agréable... mais encore de certains fichiers 😉
- Je ne pense pas que vos exemples de compiler. "fichier" est déjà défini comme un string param, de sorte que vous ne pouvez pas faire cette déclaration à l'aide du bloc.
- Grande technique, merci Marc! Si elle aide à tous ceux que j'ai mis en place un blog concernant l'utilisation de ce pour en faciliter la lecture csv dans linqpad: developertipoftheday.com/2012/10/read-csv-in-linqpad.html
- le lien fourni ci-dessus par Marc n'est plus valable, pouvez-vous veuillez donner le nouveau lien
- Corrigé, merci.
- J'ai ni compris, ni jamais utilisé le "rendement" jusqu'à aujourd'hui, malgré 20 ans de programmation C#. C'est un simple et très bon exemple! Merci aussi pour ça 😉
- Cadre comprend maintenant Fichier.ReadLines() qui fait la même chose que ci-dessus code static IEnumerable<string> ReadFrom(string file), droit?
InformationsquelleAutor Marc Gravell
23

Il est plus simple de lire une ligne et de vérifier si oui ou non nul que pour vérifier EndOfStream tout le temps.

Cependant, j'ai aussi un LineReader classe dans MiscUtil qui rend tout cela beaucoup plus simple - fondamentalement, il expose un fichier (ou un Func<TextReader> comme un IEnumerable<string> qui vous permet de faire LINQ des trucs sur elle. Ainsi, vous pouvez faire des choses comme:
```
var query = from file in Directory.GetFiles("*.log")
            from line in new LineReader(file)
            where line.Length > 0
            select new AddOn(line); //or whatever
```
Le cœur de LineReader est-ce la mise en œuvre de IEnumerable<string>.GetEnumerator:
```
public IEnumerator<string> GetEnumerator()
{
    using (TextReader reader = dataSource())
    {
        string line;
        while ((line = reader.ReadLine()) != null)
        {
            yield return line;
        }
    }
}
```
Presque tout le reste de la source est de simplement donner de la souplesse de mise en place dataSource (qui est un Func<TextReader>).
- Comment fermer le fichier? Et la libération de la ressource?
- Le using déclaration n'est que déjà la dataSource() appel d'ouvrir le fichier, et donc il va être éliminés à la fin de la using déclaration.
InformationsquelleAutor Jon Skeet
1

NOTE: Vous avez besoin de regarder dehors pour le IEnumerable<T> solution, car elle entraîne dans le fichier ouvert pour la durée de traitement.

Par exemple, avec Marc Gravel réponse:
```
foreach(var record in ReadFrom("myfile.csv")) {
    DoLongProcessOn(record);
}
```
le fichier restera ouvert pour l'ensemble du traitement.
- Vrai, mais "fichier ouvert pendant une longue période, mais pas de mise en mémoire tampon" est souvent mieux que "beaucoup de mémoire monopolisé pendant une longue période"
- C'est vrai - mais, fondamentalement, vous avez trois choix: charger le lot d'un seul coup (d'échec pour les gros fichiers); tenir le fichier à ouvrir (comme vous le mentionnez); rouvrez le fichier régulièrement (a un certain nombre de questions). Dans de très nombreux cas, je crois que le streaming et qui détient le fichier ouvert est la meilleure solution.
- Oui, c'est probablement une meilleure solution pour garder le dossier ouvert, mais vous avez juste besoin d'être loin de l'implication
- Désolé pour le nom de la typo, il y a Marc
- C'est certainement quelque chose à garder à l'esprit comme un effet indésirable inattendu, mais je suis d'accord avec Jon en ce qu'il ne sembler la meilleure solution.
- Merci d'ajouter un commentaire si vous votez ce
InformationsquelleAutor David Kemp

Merci à tous pour vos réponses! J'ai décidé d'aller avec un mélange, se concentrant principalement sur de Marc, mais, comme j'ai seulement besoin de lire les lignes d'un fichier. Je suppose qu'on pourrait dire de séparation est nécessaire partout, mais hé, la vie est trop courte!

Concernant la tenue du fichier ouvert, qui ne va pas être un problème dans ce cas, le code est une partie d'une application de bureau.

Enfin, j'ai remarqué que vous tous utilisés minuscule string. Je sais en Java il y a une différence entre capitalisés et non capitalisés de la chaîne, mais j'ai pensé en C# minuscule string était juste une référence à capitalisés Chaîne?

public void Load(AddonCollection<T> collection)
{
    //read from file
    var query =
        from line in LineReader(_LstFilename)
        where line.Length > 0
        select CreateAddon(line);

    //add results to collection
    collection.AddRange(query);
}

protected T CreateAddon(String line)
{
    //create addon
    T addon = new T();
    addon.Load(line, _BaseDir);

    return addon;
}

protected static IEnumerable<String> LineReader(String fileName)
{
    String line;
    using (var file = System.IO.File.OpenText(fileName))
    {
        //read each line, ensuring not null (EOF)
        while ((line = file.ReadLine()) != null)
        {
            //return trimmed line
            yield return line.Trim();
        }
    }
}

Pourquoi êtes-vous en passant la collection dans la méthode Load? Au moins l'appeler LoadInto si vous allez le faire 😉

InformationsquelleAutor Luca Spiller

0

Depuis .NET 4.0, le Fichier.ReadLines() méthode est disponible.
```
int count = File.ReadLines(filepath).Count(line => line.StartsWith(">"));
```
InformationsquelleAutor user7610

Vous devez vous connecter pour publier un commentaire.