Reducir lineas de codigo
 

Hola estoy haciendo un codigo basandome en un manual de lectura de todo tipo de archivos y estoy tratando de optimizar el codigo porque me han quedado muchas lineas de codigo , el codigo es este :

Código Delphi [-]
function read_file(archivo: String): AnsiString;
var
  F: File;
  contenido: AnsiString;
  limite: Integer;
  leyendo: Integer;
  tipo: Byte;
begin

  Result := '';
  tipo := FileMode;
  FileMode := 0;
  AssignFile(F, archivo);
  Reset(F, 1);

  if (IOResult = 0) then
  begin
    limite := Filelimite(F);
    while (limite > 1024) do
    begin
      SetLength(contenido, 1024);
      BlockRead(F, contenido[1], 1024, leyendo);
      Result := Result + contenido;
      Dec(limite, leyendo);
    end;
    SetLength(contenido, limite);
    BlockRead(F, contenido[1], limite);
    Result := Result + contenido;
    CloseFile(F);
  end;

  FileMode := tipo;
end;

El tema es que no quiero usar classes porque ya hice un codigo que funciona perfecto pero como es una aplicacion consola hace que el programa pese mas de lo habitual :

Código Delphi [-]

uses Classes;

function read_file(const FileName: String): AnsiString;
var
  Stream: TFileStream;
begin
  Stream := TFileStream.Create(FileName, fmOpenRead);
  try
    SetLength(Result, Stream.Size);        
    Stream.ReadBuffer(Pointer(Result)^, Stream.Size);
   finally
     Stream.Free;
   end;
 end;

Ya reduci las lineas de codigo del codigo inicial lo mas que puede , ¿ Hay alguna forma de reducir mas el codigo inicial sin tener que usar Classes ?

Reducir lineas, reducir peso del ejecutable u optimizar rendimiento? Igual me equivoco pero creo que no tiene porque ser lo mismos. En teoria a la hora del compilar el compilador se encarga de optimizar a su manera lo que ha escrito el programador y en bastantes ocasiones fuentes con bastantes diferencias dan como resultado el mismo exe.
Yo por proponer algo propondria que cuando pases a un funcion como parametro una string cuyo valor no vaya a cambiar durante la ejecución de la función, lo hagas como constante (cosa que por cierto haces cuando usas clases). No te va a reducir código, es mas añade unos cuantos caracteres mas pero el rendimiento debería mejorar bastante.

Teniendo en cuenta que la cantidad de líneas no es relevante al rendimiento del programa, se me ocurre que si Filelimite(F) devuelve el tamaño total de un archivo, no es necesario utilizarlo. Solo harías el while, comprobando que los bytes leídos son mas que 0.
Obviamente puedes quitar las líneas en blanco que dejas en la función.
También puedes poner todo en una gran línea.

En cuanto a optimización, el establecer la longitud de la cadena, puedes hacerlo solo una vez, pues todas las lecturas posteriores serán iguales.

Código Delphi [-]
    limite := Filelimite(F);
    SetLength(contenido, 1024);
    while (limite > 1024) do
    begin
      BlockRead(F, contenido[1], 1024, leyendo);
      Result := Result + contenido;
      Dec(limite, leyendo);
    end;