Delphi: альтернатива использованию Reset / ReadLn для чтения текстовых файлов

В последних версиях Delphi вы можете использовать TStreamReader. Создайте его с помощью своего файлового потока, а затем вызовите его ReadLine метод (унаследованный из TTextReader).

Вариант для всех версий Delphi - использовать StreamIO Питера Боула unit, что дает вам AssignStream. Он работает так же, как AssignFile, но для потоков, а не для имен файлов. После того, как вы использовали эту функцию для связывания потока с переменной TextFile, вы можете вызвать ReadLn и другие функции ввода-вывода для него, как и для любого другого файла.

Вы можете использовать этот пример кода:

TTextStream = class(TObject)
      private
        FHost: TStream;
        FOffset,FSize: Integer;
        FBuffer: array[0..1023] of Char;
        FEOF: Boolean;
        function FillBuffer: Boolean;
      protected
        property Host: TStream read FHost;
      public
        constructor Create(AHost: TStream);
        destructor Destroy; override;
        function ReadLn: string; overload;
        function ReadLn(out Data: string): Boolean; overload;
        property EOF: Boolean read FEOF;
        property HostStream: TStream read FHost;
        property Offset: Integer read FOffset write FOffset;
      end;

    { TTextStream }

    constructor TTextStream.Create(AHost: TStream);
    begin
      FHost := AHost;
      FillBuffer;
    end;

    destructor TTextStream.Destroy;
    begin
      FHost.Free;
      inherited Destroy;
    end;

    function TTextStream.FillBuffer: Boolean;
    begin
      FOffset := 0;
      FSize := FHost.Read(FBuffer,SizeOf(FBuffer));
      Result := FSize > 0;
      FEOF := Result;
    end;

    function TTextStream.ReadLn(out Data: string): Boolean;
    var
      Len, Start: Integer;
      EOLChar: Char;
    begin
      Data:='';
      Result:=False;
      repeat
        if FOffset>=FSize then
          if not FillBuffer then
            Exit; // no more data to read from stream -> exit
        Result:=True;
        Start:=FOffset;
        while (FOffset<FSize) and (not (FBuffer[FOffset] in [#13,#10])) do
          Inc(FOffset);
        Len:=FOffset-Start;
        if Len>0 then begin
          SetLength(Data,Length(Data)+Len);
          Move(FBuffer[Start],Data[Succ(Length(Data)-Len)],Len);
        end else
          Data:='';
      until FOffset<>FSize; // EOL char found
      EOLChar:=FBuffer[FOffset];
      Inc(FOffset);
      if (FOffset=FSize) then
        if not FillBuffer then
          Exit;
      if FBuffer[FOffset] in ([#13,#10]-[EOLChar]) then begin
        Inc(FOffset);
        if (FOffset=FSize) then
          FillBuffer;
      end;
    end;

    function TTextStream.ReadLn: string;
    begin
      ReadLn(Result);
    end;

Использование:

procedure ReadFileByLine(Filename: string);
var
  sLine: string;
  tsFile: TTextStream;
begin
  tsFile := TTextStream.Create(TFileStream.Create(Filename, fmOpenRead or    fmShareDenyWrite));
  try
    while tsFile.ReadLn(sLine) do
    begin
      //sLine is your line
    end;
  finally
    tsFile.Free;
  end;
end;

Если вам нужна поддержка ansi и Unicode в старых версиях Delphis, вы можете использовать мой GpTextFile или GpTextStream.

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

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

Это работает довольно быстро даже для больших файлов.

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

Чтение одной строки за раз без какой-либо буферизации просто слишком медленно для больших файлов.

У меня была такая же проблема несколько лет назад, особенно проблема блокировки файла. Что я сделал, так это использовал файл чтения низкого уровня из шеллапи. Я знаю, что вопрос устарел с момента моего ответа (2 года), но, возможно, мой вклад может кому-то помочь в будущем.

const
  BUFF_SIZE = $8000;
var
  dwread:LongWord;
  hFile: THandle;
  datafile : array [0..BUFF_SIZE-1] of char;

hFile := createfile(PChar(filename)), GENERIC_READ, FILE_SHARE_READ or FILE_SHARE_WRITE, nil, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, 0);
SetFilePointer(hFile, 0, nil, FILE_BEGIN);
myEOF := false;
try
  Readfile(hFile, datafile, BUFF_SIZE, dwread, nil);   
  while (dwread > 0) and (not myEOF) do
  begin
    if dwread = BUFF_SIZE then
    begin
      apos := LastDelimiter(#10#13, datafile);
      if apos = BUFF_SIZE then inc(apos);
      SetFilePointer(hFile, aPos-BUFF_SIZE, nil, FILE_CURRENT);
    end
    else myEOF := true;
    Readfile(hFile, datafile, BUFF_SIZE, dwread, nil);
  end;
finally
   closehandle(hFile);
end;

Для меня улучшение скорости оказалось значительным.

Почему бы просто не читать строки файла непосредственно из самого TFileStream по одной?

то есть (в псевдокоде):

  readline: 
    while NOT EOF and (readchar <> EOL) do
      appendchar to result


  while NOT EOF do
  begin
    s := readline
    process s
  end;

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