Einlesen einer FORTRAN Binärdatei mit Delphi

[Uwe Raabe]

Der Wiki-Eintrag ist an dieser Stelle irreführend. Es ist wirklich jede Datei eine Binärdatei. Textdateien sind eine Untermenge davon und auch davon gibt es wieder verschiedene Untermengen mit diversen Encodings und Line-Endings.

Fragte doch neulich jemand, warum denn beim Einlesen mit TEncoding.ANSI keine Fehlermeldung käme, wenn man dem Programm eine Unicode-Datei unterjubelt.

Dein BlockRead-Record-Ansatz ist zwar ziemlich Old-School, aber würde hier durchaus funktionieren - wenn die Datensätze wirklich alle gleich lang sind. Das ist aber nicht zwingend der Fall. Unter der Annahme, daß das eine Byte vor und nach den Nutzdaten wirklich die Recordlänge angibt (255 Byte Maximum - unglaublich!), dann würde sich eigentlich eher ein Stream-Wrapper oder ein class helper for TStream anbieten.

[Mavarik]

Zitat von Uwe Raabe:

Dein BlockRead-Record-Ansatz ist zwar ziemlich Old-School, aber würde hier durchaus funktionieren

Old-School = Good-School;

Eine Binärdatei ist für mich eine 1:1 Entsprechungen eine Speicher-Datenstruktur ohne ausgerichtete Felder -{$A1}. Keine längen Bytes, Trennzeichen, kein ^Z am Ende usw.

Wenn ich ein Byte in eine Datei schreibe, muss die Datei auch nur ein Byte lang sein.
Wenn ich 100 Datensätze mit je 15 Byte weg schreibe muss die Datei auch 1500 Bytes enthalten. Nicht mehr und nicht weniger.

Dann ist es in meinem Sprachgebrauch eine Binärdatei...

Mavarik

[Tenobaal]

Danke euch, ihr habt mir schon sehr weitergeholfen
Ich bin heute auf den Beitrag gestoßen http://stackoverflow.com/questions/8...ed-file-format
Zumindest verstehe ich nun, wie die Struktur der Dateien aufgebaut ist.

[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