Einlesen einer FORTRAN Binärdatei mit Delphi

[Namenloser]

Zitat von Mavarik:

Dann schreibt diese kleine Delphi Programm das gleiche weg... (Oder liest es ein).
Auch ohne eine Monster-Class dafür zu Programmieren.

2014 noch Leuten dazu zu raten, die alten Pascal-Files zu verwenden
Man muss doch mit Streams auch nicht gleich eine riesige, overengineerte Monster-Class programmieren. (Generics sind allerdings ganz nett in dem Fall, meine ich. Kann sein, dass die Syntax falsch ist, ich bin dank der Preise der neuen Delphi-Versionen leider nie in den Genuss gekommen.)

Delphi-Quellcode:

type
  TFortranStream = class
  protected
    FStream: TStream;
  public
    constructor Create(Stream: TStream);
    procedure Read<T>(var Rec: T);
    procedure Write<T>(const Rec: T);
  end;

implementation

{$R *.dfm}

constructor TFortranStream.Create(Stream: TStream);
begin
  FStream := Stream;
end;

procedure TFortranStream.Read<T>(var Rec: T);
var
  Len: Byte;
begin
  FStream.Read(@Len, sizeof(Byte));
  FStream.Read(@Rec, sizeof(T));
end;

procedure TFortranStream.Write<T>(const Rec: T);
var
  Len: Byte;
begin
  Len := sizeof(T);
  FStream.Write(@Len, sizeof(Len));
  FStream.Write(@Rec, sizeof(Rec));
  FStream.Write(@Len, sizeof(Len));
end;

type
  TFortranRecord = packed record
    A : Double;
    C,
    D : Integer;
    S : array[1..3] of AnsiChar;
  end;

procedure TForm1.Button1Click(Sender: TObject);
var
  F : File;
  FileStream: TFileStream;
  Fortran: TFortranStream;
  Rec: TFortranRecord;
begin
  FileStream := TFileStream.Create('Test.net');
  Fortran := TFortranStream.Create(FileStream);

  Rec.A := 1.0;
  Rec.C := 2;
  Rec.D := 2;
  Rec.S[1] := 'A';
  Rec.S[2] := 'B';
  Rec.S[3] := 'C';

  Fortran.Write<TFortranRecord>(Rec);
  
  Fortran.Free;
  FileStream.Free;
end;

(Fehlerbehandlung sollte da natürlich noch rein, hat dein Beispiel aber auch nicht).

[Dejan Vu]

Ich persönlich würde das über einen Stream lösen und jedes Feld einzeln einlesen. Das ist nur unwesentlich komplexer als ein Blockread mit Record, aber man sieht genau, was Sache ist. Letztendlich ist es Geschmackssache, denn wenn man den Record entsprechend deklariert, sieht man genauso, was Sache ist.

[Mavarik]

Zitat von Namenloser:

2014 noch Leuten dazu zu raten, die alten Pascal-Files zu verwenden

Wieso "Shock"?

Ja natürlich Blockwrite... Wieso auch nicht.. Abgesehen davon das es Blockbezogen fast 100%ig das gleiche ist
(vielleicht ein klein wenig weniger overhead).

Ein Blockwrite ruft folgendes auf:

1. Function _blockwrite
2. BlockIO
3. IOProc (Kernel32 "Writefile");

"Dein Stream" ruft folgendes auf:

1. TStream.Write
2. Filewrite
3. WriteFile (Kernal32 "Writefile");

Lassen wir mal außer acht, dass der Blockwrite wenige Taktcycle weniger braucht.

Also macht "mein" alten Pascal-Files genau das gleiche... Noch Fragen?

[Namenloser]

Kannst du mit deinem Blockwrite/Blockread mal eben nachträglich auf eine andere Datenquelle umsteigen, z.B. einen MemoryStream?

Ich hab nicht grundsätzlich etwas gegen althergebrachte Methoden, aber Streams sind hier meiner Meinung nach in jeder Hinsicht überlegen. Man braucht ja nicht mal mehr Code – man kann mit Streams – wenn man will – genau so programmieren wie mit Pascal-Files. Aber man hat halt zusätzlich noch mehr Optionen.

Zitat:

Lassen wir mal außer acht, dass der Blockwrite wenige Taktcycle weniger braucht.

Ja, lassen wir besser wirklich außer acht. Ist schließlich absolut irrelevant, wenn die Methode 1ns länger braucht, wenn der Festplattenzugriff 10 000× so lange dauert.

Viel relevanter für die Performance ist, wie groß die Blöcke sind, die man einliest oder schreibt, und da würde ich wenn dann vermuten, dass das modernere API moderne Hardware besser auslastet.

[Dejan Vu]

Zitat von Mavarik:

Also macht "mein" alten Pascal-Files genau das gleiche... Noch Fragen?

Ja. Wieso dann nicht gleich Maschinencode?. Ist doch auch genau das gleiche.

[Mavarik]

Zitat von Dejan Vu:

Zitat von Mavarik:

Also macht "mein" alten Pascal-Files genau das gleiche... Noch Fragen?

Ja. Wieso dann nicht gleich Maschinencode?. Ist doch auch genau das gleiche.

Da wo es noch Sinn macht... Warum nicht?

Zitat von Namenloser:

...und da würde ich wenn dann vermuten, dass das modernere API moderne Hardware besser auslastet.

Das ist ja der Witz... Geht ja beides auf die Kernel... Also genau die gleiche API.

Aber das hat jetzt echt nix mehr mit diesem Thread zu tun... Also würde sagen, wir beenden das hier...

[p80286]

Ein kleiner Nachsatz sei mir gestattet. Bis XP SP2..... (gefühlt) war das Block.. schneller als der Filestream (mit entsprechender Buffersize!) danach war es umgekehrt, darum hab ich längst alle Block.. durch TFilestream ersetzt.
Und "Monsterklassen" sind dafür auch nicht nötig.

Delphi-Quellcode:

fs.create(....,...);
repeat
  gelesen:=fs.read(buffer,zulesen);
until gelesen<zulesen;
fs.free;

Gruß
K-H