Как узнать позицию (номер строки) средства чтения потоков в текстовом файле?

Чрезвычайно легко предоставить оболочку для подсчета строк для любого TextReader:

public class PositioningReader : TextReader {
    private TextReader _inner;
    public PositioningReader(TextReader inner) {
        _inner = inner;
    }
    public override void Close() {
        _inner.Close();
    }
    public override int Peek() {
        return _inner.Peek();
    }
    public override int Read() {
        var c = _inner.Read();
        if (c >= 0)
            AdvancePosition((Char)c);
        return c;
    }

    private int _linePos = 0;
    public int LinePos { get { return _linePos; } }

    private int _charPos = 0;
    public int CharPos { get { return _charPos; } }

    private int _matched = 0;
    private void AdvancePosition(Char c) {
        if (Environment.NewLine[_matched] == c) {
            _matched++;
            if (_matched == Environment.NewLine.Length) {
                _linePos++;
                _charPos = 0;
                _matched = 0;
            }
        }
        else {
            _matched = 0;
            _charPos++;
        }
    }
}

Недостатки (для краткости):

1. Не проверяет аргумент конструктора на null
2. Не распознает альтернативные способы завершения строк. Будет несовместимо с поведением ReadLine() при чтении файлов, разделенных необработанными \r или \n.
3. Does not override "block"-level methods like Read(char[], int, int), ReadBlock, ReadLine, ReadToEnd. TextReader implementation works correctly since it routes everything else to Read(); however, better performance could be achieved by
   • overriding those methods via routing calls to _inner. instead of base.
   • передача прочитанных символов в AdvancePosition. См. пример реализации ReadBlock:

public override int ReadBlock(char[] buffer, int index, int count) {
    var readCount = _inner.ReadBlock(buffer, index, count);    
    for (int i = 0; i < readCount; i++)
        AdvancePosition(buffer[index + i]);
    return readCount;
}

Я наткнулся на этот пост, когда искал решение аналогичной проблемы, когда мне нужно было найти StreamReader для определенных строк. В итоге я создал два метода расширения для получения и установки позиции в StreamReader. На самом деле он не обеспечивает количество номеров строк, но на практике я просто беру позицию перед каждым ReadLine(), и если строка представляет интерес, я сохраняю начальную позицию для установки позже, чтобы вернуться к строке следующим образом:

var index = streamReader.GetPosition();
var line1 = streamReader.ReadLine();

streamReader.SetPosition(index);
var line2 = streamReader.ReadLine();

Assert.AreEqual(line1, line2);

и важная часть:

public static class StreamReaderExtensions
{
    readonly static FieldInfo charPosField = typeof(StreamReader).GetField("charPos", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);
    readonly static FieldInfo byteLenField = typeof(StreamReader).GetField("byteLen", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);
    readonly static FieldInfo charBufferField = typeof(StreamReader).GetField("charBuffer", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);

    public static long GetPosition(this StreamReader reader)
    {
        // shift position back from BaseStream.Position by the number of bytes read
        // into internal buffer.
        int byteLen = (int)byteLenField.GetValue(reader);
        var position = reader.BaseStream.Position - byteLen;

        // if we have consumed chars from the buffer we need to calculate how many
        // bytes they represent in the current encoding and add that to the position.
        int charPos = (int)charPosField.GetValue(reader);
        if (charPos > 0)
        {
            var charBuffer = (char[])charBufferField.GetValue(reader);
            var encoding = reader.CurrentEncoding;
            var bytesConsumed = encoding.GetBytes(charBuffer, 0, charPos).Length;
            position += bytesConsumed;
        }

        return position;
    }

    public static void SetPosition(this StreamReader reader, long position)
    {
        reader.DiscardBufferedData();
        reader.BaseStream.Seek(position, SeekOrigin.Begin);
    }
}

Это работает очень хорошо для меня, и в зависимости от вашей терпимости к использованию отражения, он считает, что это довольно простое решение.

Предостережения:

1. Хотя я провел несколько простых тестов с использованием различных опций System.Text.Encoding, почти все данные, которые я использую, представляют собой простые текстовые файлы (ASCII).
2. Я всегда использую только метод StreamReader.ReadLine(), и хотя краткий обзор исходного кода для StreamReader, кажется, указывает, что он все еще будет работать при использовании других методов чтения, я действительно не тестировал этот сценарий.

Нет, не совсем возможно. Концепция «номера строки» основана на фактических данных, которые уже были прочитаны, а не только на позиции. Например, если вы будете искать () считыватель в произвольной позиции, он на самом деле не будет читать эти данные, поэтому он не сможет определить номер строки.

Единственный способ сделать это - следить за этим самостоятельно.

No.

Учтите, что можно искать любую позицию, используя базовый объект потока (который может находиться в любой точке любой строки). Теперь подумайте, как это повлияет на любой счетчик, хранящийся в StreamReader.

Должен ли StreamReader выяснить, на какой строке он сейчас находится? Должен ли он просто держать несколько прочитанных строк, независимо от положения в файле?

Есть больше вопросов, чем просто эти, которые сделают это кошмаром для реализации, имхо.

Вот парень, который реализовал StreamReader с методом ReadLine(), который регистрирует позицию в файле.

http://www.daniweb.com/forums/thread35078.html

Я предполагаю, что нужно наследоваться от StreamReader, а затем добавить дополнительный метод в специальный класс вместе с некоторыми свойствами (_lineLength + _bytesRead):

 // Reads a line. A line is defined as a sequence of characters followed by
 // a carriage return ('\r'), a line feed ('\n'), or a carriage return
 // immediately followed by a line feed. The resulting string does not
 // contain the terminating carriage return and/or line feed. The returned
 // value is null if the end of the input stream has been reached.
 //
 /// <include file='doc\myStreamReader.uex' path='docs/doc[@for="myStreamReader.ReadLine"]/*' />
 public override String ReadLine()
 {
          _lineLength = 0;
          //if (stream == null)
          //       __Error.ReaderClosed();
          if (charPos == charLen)
          {
                   if (ReadBuffer() == 0) return null;
          }
          StringBuilder sb = null;
          do
          {
                   int i = charPos;
                   do
                   {
                           char ch = charBuffer[i];
                           int EolChars = 0;
                           if (ch == '\r' || ch == '\n')
                           {
                                    EolChars = 1;
                                    String s;
                                    if (sb != null)
                                    {
                                             sb.Append(charBuffer, charPos, i - charPos);
                                             s = sb.ToString();
                                    }
                                    else
                                    {
                                             s = new String(charBuffer, charPos, i - charPos);
                                    }
                                    charPos = i + 1;
                                    if (ch == '\r' && (charPos < charLen || ReadBuffer() > 0))
                                    {
                                             if (charBuffer[charPos] == '\n')
                                             {
                                                      charPos++;
                                                      EolChars = 2;
                                             }
                                    }
                                    _lineLength = s.Length + EolChars;
                                    _bytesRead = _bytesRead + _lineLength;
                                    return s;
                           }
                           i++;
                   } while (i < charLen);
                   i = charLen - charPos;
                   if (sb == null) sb = new StringBuilder(i + 80);
                   sb.Append(charBuffer, charPos, i);
          } while (ReadBuffer() > 0);
          string ss = sb.ToString();
          _lineLength = ss.Length;
          _bytesRead = _bytesRead + _lineLength;
          return ss;
 }

Подумайте, что в коде есть небольшая ошибка, поскольку длина строки используется для вычисления позиции файла вместо использования фактически прочитанных байтов (отсутствует поддержка файлов в кодировке UTF8 и UTF16).

Я пришел сюда в поисках чего-то простого. Если вы просто используете ReadLine() и не заботитесь об использовании Seek() или чего-то еще, просто создайте простой подкласс StreamReader

class CountingReader : StreamReader {
    private int _lineNumber = 0;
    public int LineNumber { get { return _lineNumber; } }

    public CountingReader(Stream stream) : base(stream) { }

    public override string ReadLine() {
        _lineNumber++;
        return base.ReadLine();
    }
}

а затем вы делаете это обычным способом, скажем, из объекта FileInfo с именем file

CountingReader reader = new CountingReader(file.OpenRead())

и вы только что прочитали свойство reader.LineNumber.

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

Я попытался написать такой класс сейчас. Вроде работает правильно, но довольно медленно. Это должно быть хорошо, когда производительность не имеет решающего значения (она не настолько медленная, см. ниже).

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

Я сделал очень простое сравнение производительности метода ReadLine (который, как мне кажется, является самым слабым местом этой реализации) с StreamReader, и разница составляет почти порядок. Я получил 22 МБ/с, используя класс StreamReaderEx, но почти в 9 раз больше, используя StreamReader напрямую (на моем ноутбуке с SSD). Хотя это может быть интересно, я не знаю, как правильно провести тест на чтение; возможно, используя 2 одинаковых файла, каждый из которых больше, чем дисковый буфер, и читая их поочередно ..? По крайней мере, мой простой тест дает стабильные результаты, когда я запускаю его несколько раз и независимо от того, какой класс сначала читает тестовый файл.

Символ NewLine по умолчанию имеет значение Environment.NewLine, но может быть установлен на любую строку длиной 1 или 2. Читатель рассматривает только этот символ как новую строку, что может быть недостатком. По крайней мере, я знаю, что Visual Studio довольно много раз подсказывала мне, что файл, который я открываю, «имеет несогласованные новые строки».

Обратите внимание, что я не включил класс Guard; это простой служебный класс, и из контекста должно быть понятно, как его заменить. Вы даже можете удалить его, но вы потеряете проверку некоторых аргументов, и, таким образом, полученный код будет более далеким от «правильного». Например, Guard.NotNull(s, "s") просто проверяет, что s не равно null, вызывая ArgumentNullException (с именем аргумента "s", следовательно, второй параметр), если это так.

Хватит болтать, вот код:

public class StreamReaderEx : StreamReader
{
    // NewLine characters (magic value -1: "not used").
    int newLine1, newLine2;

    // The last character read was the first character of the NewLine symbol AND we are using a two-character symbol.
    bool insideNewLine;

    // StringBuilder used for ReadLine implementation.
    StringBuilder lineBuilder = new StringBuilder();


    public StreamReaderEx(string path, string newLine = "\r\n") : base(path)
    {
        init(newLine);
    }


    public StreamReaderEx(Stream s, string newLine = "\r\n") : base(s)
    {
        init(newLine);
    }


    public string NewLine
    {
        get { return "" + (char)newLine1 + (char)newLine2; }
        private set
        {
            Guard.NotNull(value, "value");
            Guard.Range(value.Length, 1, 2, "Only 1 to 2 character NewLine symbols are supported.");

            newLine1 = value[0];
            newLine2 = (value.Length == 2 ? value[1] : -1);
        }
    }


    public int LineNumber { get; private set; }
    public int LinePosition { get; private set; }


    public override int Read()
    {
        int next = base.Read();
        trackTextPosition(next);
        return next;
    }


    public override int Read(char[] buffer, int index, int count)
    {
        int n = base.Read(buffer, index, count);
        for (int i = 0; i