Lazarus: Datei als Byte-Array laden und Byte-Array als Datei speichern

In diesem Tutorial möchte ich euch sowohl zeigen, wie ihr eine Datei Byte für Byte lesen und in einen Array laden könnt als auch wie ihr einen Byte-Array wieder zurück in eine Datei schreiben könnt und damit den umgekehrten Weg geht.

Zunächst definieren wir uns einen Byte-Array, den wir für beide Vorgänge beziehungsweise Richtungen benötigen:

type
  TByteArr = array of Byte;

Diesen können wir jetzt zum Beispiel auf die folgende Arte und Weise mit einzelnen Bytes füllen:

var
  BA: TByteArr;
begin
  SetLength(BA, 4);
  BA[0] := 65;
  BA[1] := $41;
  BA[2] := %1000001;
  BA[3] := ord('A');

Dabei spielt es keine Rolle, ob wir die Bytes in dezimaler, hexadezimaler oder binärer Schreibweise angeben oder zum Beispiel aus einer Funktion wie ord() beziehen. Der Beispiel-Code zeigt jede dieser vier Möglichkeiten.

65 ist der ASCII Code für "A". In hexadezimaler Schreibweise entspricht die Zahl 65 der 41 und in binärer Schreibweise der 1000001. Auch ord('A') liefert uns den ASCII-Wert 65 für "A".

Wir setzen im Beispiel also alle die vier Bytes des Arrays jeweils auf den gleichen Wert. Dezimale Angaben können als einfache Integer-Zahlen in den Code geschrieben werden, hexadezimale werden mit $ gekennzeichnet und binäre Zahlen mit %. So kann der Compiler unterschieden, welche Zahl wir meinen.

Byte-Array speichern

Nun möchten wir uns ansehen, wie wir unseren Byte-Array in eine Datei speichern können. Dazu benutzen wir die folgende Prozedur, der wir einen Byte-Array und unseren gewünschten Dateinamen für die Speicherung übergeben können:

procedure SaveByteArray(AByteArray: TByteArr; const AFileName: string);
var
  AStream: TStream;
begin
  if FileExistsUTF8(AFileName) then DeleteFileUTF8(AFileName);

  AStream := TFileStreamUTF8.Create(AFileName, fmCreate);
  try
     AStream.WriteBuffer(Pointer(AByteArray)^, Length(AByteArray));
  finally
     AStream.Free;
  end;

end;  

Zunächst überprüfen wir, ob eine Datei mit dem angegebenen Namen bereits existiert und löschen diese, falls dies der Fall ist. Alternativ könnten wir vor der Löschung natürlich noch den Nutzer fragen, aber hier möchten wir uns auf das wesentliche beschränken. Anschließend erstellen wir uns einen FileStream und schreiben den Array in kompletter Länge hinein. Damit ist der Byte-Array gespeichert.

Ein Aufruf dieser Prozedur könnte so aussehen:

var
  BA: TByteArr;
begin
  SetLength(BA, 2);
  BA[0] := 65;
  BA[1] := 66;
  SaveByteArray(BA, 'datei.dat');

Hier erstellen wir uns zunächst einen Byte-Array bestehend aus zwei Elementen und benutzen anschließend die eben vorgestellte Prozedur zur Speicherung. Als ersten Parameter übergeben wir der Prozedur unseren Byte Array, als zweiten den Dateinamen.

Byte-Array laden

Nun möchten wir uns auch den umgekehrten Weg ansehen. Um eine Datei von der Festplatte in einen Byte-Array zu laden, bietet sich die folgende Funktion an, der wir einen Dateinamen als Parameter übergeben können:

function LoadByteArray(const AFileName: string): TByteArr;
var
  AStream: TStream;
  ADataLeft: Integer;
begin
  SetLength(result, 0);

  if not FileExistsUTF8(AFileName) then exit;

  AStream := TFileStreamUTF8.Create(AFileName, fmOpenRead or fmShareDenyWrite);
  try
     AStream.Position := 0;
     ADataLeft := AStream.Size;
     SetLength(result, ADataLeft div SizeOf(Byte));
     AStream.Read(PByte(result)^, ADataLeft);
  finally
     AStream.Free;
  end;

end; 

Auch in dieser Prozedur prüfen wir zunächst, ob eine Datei unter dem angegebenen Dateinamen existiert und brechen ab, falls nicht. Vorher haben wir das Result bereits auf eine Länge von 0 gesetzt, sodass die Funktion für diesen Fall einen leeren Array zurück gibt. Sollte die Datei existieren erstellen wir auch in dieser Funktion einen FileStream, den wir dazu nutzen, alle Bytes der Datei in unseren Result-Byte-Array zu lesen.

Ein Aufruf der Funktion kann dann so aussehen:

var
  BA: TByteArr;
begin
  BA := LoadByteArray('datei.dat');

Wir geben als Parameter nur einen Dateinamen an und bekommen den Byte-Array, bestehend aus den Bytes der angefragten Datei, zurück.

Byte-Array visualisieren

Bei der Arbeit mit Byte-Arrays kommt früher oder später die Frage nach dem Inhalt des Byte-Arrays auf. Dazu bietet es sich an, die Byte Arrays in hexadezimaler Form als String auszugeben. Damit würde eine Ausgabe des oben genannten Byte Arrays zum Beispiel so aussehen: "41 41 41 41".