Чтение файла построчно в C#

Я пытаюсь прочитать некоторые текстовые файлы, где каждая строка должна быть обработана. На данный момент я просто использую StreamReader, а затем читаю каждую строку в отдельности.

Мне интересно, есть ли более эффективный способ (с точки зрения LoC и читабельности) сделать это с помощью LINQ без ущерба для операционной эффективности. Примеры, которые я видел, включают загрузку всего файла в память, а затем его обработку. Однако в этом случае я не верю, что это будет очень эффективно. В первом примере файлы могут иметь размер около 50 КБ, а во втором примере не все строки файла должны быть прочитаны (размеры обычно < 10 КБ).

Можно утверждать, что в настоящее время это не имеет большого значения для этих небольших файлов, однако я считаю, что подобный подход приводит к неэффективному коду.

Первый пример:

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

Второй пример:

// 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;
        }
    }
}
Источник

4 ответа

Решение

Вы можете довольно просто написать LINQ-ридер, используя блок итератора:

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

или сделать Джона счастливым:

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;

тогда у вас есть ReadFrom(...) как лениво оцененная последовательность без буферизации, идеально подходит для Where и т.п.

Обратите внимание, что если вы используете OrderBy или стандарт GroupBy, он должен будет буферизовать данные в памяти; Если вам нужно группировать и агрегировать, "PushLINQ" имеет некоторый причудливый код, позволяющий вам выполнять агрегацию данных, но отбрасывать их (без буферизации). Объяснение Джона здесь.

Источник

Проще прочитать строку и проверить, является ли она нулевой, чем постоянно проверять EndOfStream.

Тем не менее, у меня также есть LineReader класс в MiscUtil, который делает все это намного проще - в основном он предоставляет файл (или Func<TextReader> как IEnumerable<string> который позволяет вам делать вещи LINQ поверх него. Таким образом, вы можете делать такие вещи, как:

var query = from file in Directory.GetFiles("*.log")
            from line in new LineReader(file)
            where line.Length > 0
            select new AddOn(line); // or whatever

Сердце LineReader это реализация IEnumerable<string>.GetEnumerator:

public IEnumerator<string> GetEnumerator()
{
    using (TextReader reader = dataSource())
    {
        string line;
        while ((line = reader.ReadLine()) != null)
        {
            yield return line;
        }
    }
}

Почти весь остальной источник просто дает гибкие способы настройки dataSource (который является Func<TextReader>).

Источник

Начиная с.NET 4.0, File.ReadLines() метод доступен.

int count = File.ReadLines(filepath).Count(line => line.StartsWith(">"));
Источник

ПРИМЕЧАНИЕ: вам нужно следить за IEnumerable<T> решение, так как это приведет к открытию файла на время обработки.

Например, с ответом Марка Гравелла:

foreach(var record in ReadFrom("myfile.csv")) {
    DoLongProcessOn(record);
}

файл останется открытым для всей обработки.

Источник

Спасибо всем за ваши ответы! Я решил пойти со смесью, в основном сосредоточившись на Марке, хотя мне нужно будет только читать строки из файла. Я думаю, вы могли бы утверждать, что разделение необходимо везде, но хех, жизнь слишком коротка!

Что касается сохранения файла открытым, то в этом случае это не будет проблемой, так как код является частью настольного приложения.

Наконец, я заметил, что вы все использовали строчную строку. Я знаю, что в Java есть разница между заглавными и не заглавными буквами, но я подумал, что строчная строчка в C# была просто ссылкой на заглавную строку?

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();
        }
    }
}
Источник
Другие вопросы по тегам