Filehandling Basics: Wichtige Dateioperationen
Im folgenden einige gegebene Funktionen, die in Delphi direkt eingesetzt schon den Zugriff auf Dateien geben
können
file
Reserviertes Wort. Leitet die Typisierung zum Zugriff auf eine Datei ein.
Das Beispiel zeigt, wie eine Datei benutzt werden kann, die aus einzelnen Bytes besteht.
|
var f : file of Byte; |
AssignFile(f: Zeiger auf die Datei; Dateiname: String)
Hier wird der Name der Datei festgelegt und an den Zeiger den man mit f typisiert hat, gebunden.
myFileName hat in diesem Beispiel schon dem absoluten Pfad zur Datei inklusive dem Dateinamen,
so dass nun mit f weitergearbeitet werden kann.
|
//... AssignFile(f, myFileName); //... |
Reset(f: File..)
Setzt den Lese-Zeiger an den Anfang zurück. Hierbei ist wichtig, dass die Datei bereits
existieren muss. In früheren Delphi-Versionen war der Reset zunächst unabdingbar, da ansonsten der
"Zeiger" auf die Datei beliebig verschieden sein konnte, da eben nicht initialisiert.
|
//... Reset(f); //... |
Rewrite(f: File..)
Setzt die Dateigröße auf 0 und erstellt eine Datei, falls sie noch nicht existiert.
|
//... Rewrite(f); //... |
Read(f:File..; data)
Lest spezifizierte Daten ein. Wenn wir f wie oben im Beispiel deklariert hätten, wäre "data"
vom Typ Byte, so dass Byte für Byte ausgelesen werden könnte.
|
//... Read(f, data); //... |
Write(f:File..; data)
Schreibt Daten in die Datei. Hier auch wieder, "data" vom Typ Byte.
|
//... Write(f, data); //... |
CloseFile(f:File...)
Schließt einen offenen Dateizeiger. Geöffnete Dateien können nicht von anderen
Programmen geöffnet werden. Daher sollte man Dateien nur so kurz wie möglich öffnen.
|
//... CloseFile(f); //... |
eof(f:File...):Boolean
eof = End Of File. Wird meist in While-schleifen benutzt um zu schauen, ob man schon am Ende der
Datei angekommen ist. Wichtig hierbei ist das Zurücksetzen (Reset) des Lesezeigers der Datei.
|
//... while not eof(f) do begin //... end; //... |
seek(f:File...;l:LongInt);
An eine Position innerhalb der Datei springen. Dies ist dann sinnvoll, wenn man Daten ab einer Position z.b.
einfach "nachladen" möchte. posInFile ist hierbei die Position, ab der gelesen oder etwas geschrieben
werden soll.
|
//... seek(f, posInFile); //... |
FileExists(FileName : String);
Gibt an, ob eine Datei existiert.
|
//... if FileExists(myFileName) then //... |
Diese Dateioperationen sind auch mit der Arbeit mit Datenströhmen wichtig.
Die s.g. Streams können mittels Read/Write/Seek-Methoden quasi wie Dateien behandelt werden.
Speichern und Laden von eigenen Dateitypen
Zunächst müssen wir hierbei erstmal genau definieren: Was ist eine Datei und was ein Dateityp?
Nun ja, was eine Datei ist dürfte eigentlich jedem klar sein. Eine Datei speichert Daten, die man eingegeben
hat, oder Daten die von bestimmten Programmen benötigt werden. Aber auch Programme sind Dateien. Und genau hier
setzt der begriff Dateityp an. Programme sind Dateien vom Typ Programm. Es wird auch oft als ausführbare Datei
bezeichnet. Diese haben unter Windows beispielsweise die Endungen .exe, .com, .bat und .cmd . Die letzteren
Zwei, die so genannten Batch-Dateien, sind in Text-form gespeichert und können eigenhändig in einem
beliebigen Editor modifiziert werden.
Als Beispiel zu unserem eigenen Dateiformat werden wir nun das Projekt von
Step 07 - Arrays und Records
weiterentwickeln.
Hierbei ging es bereits um (statische) Arrays und Records um Datenbestände in einer Datei zu speichern.
Wer das nicht neu erstellen möchte, kann aus dem Kapitel den Source einfach kopieren und hier entsprechend
weiterentwickeln. (Wer allerdings von Grundauf neu anfangen möchte, kann das auch - dann allerdings bitte
nur einmal die Eingabe von Nick bis UIN in das Formular und beim zweiten Unterpunkt bei der GUI weitermachen)
Das Formular sollte dann nach dem öffnen wie folgt aussehen:
Wir werden die Beispielanwendung nun folgendermaßen modifizieren:
Die GUI
- 3 der 4 Eingabeblöcke müssen entfernt werden
- der nun noch vorhandene Eingabeblock sollte zentriert werden, und bei der Benennung keine Zahlen mehr enthalten (also EdNick1 wird zu EdNick)
- Zudem im Objectinspector alle Edits auf Enabled := false;
- Die Buttons "Eingabe übernehmen" und "Eingabe anzeigen" links und rechts des Blockes positionieren, den Namen auf BtnPrevious bzw. auf BtnNext und die Aufschrift auf Zurück bzw. Weiter ändern.
- Ein Label lblPos, welches die aktuelle Position anzeigen soll, wird hinzugefügt und unter dem Eingabeblock positioniert.
- Ein weiterer Button "BtnNew" soll das Hinzufügen von Daten realisieren und ein Button "BtnDelete" das Löschen eines Datensatzes.
Die GUI sollte dann in etwa so aussehen:
Doch bevor es lauffähig wird:
Korrektur des Quellcodes:
- Ein Integer-Feld deklarieren, welches "fCurrentIndex" heisst und bei OnFormCreate auf 0 initialisiert wird.
- Die fehlerhaften Zeilen aus BtnNextClick und entfernen.
- Die Methoden BtnPreviousClick sowie BtnNextClick können jetzt geleert werden. Einmal Strg+S und schon sollten die Methoden verschwinden (Falls eine bleiben sollte, was in meinem Versuch mit Delphi 10.4.2 so der Fall war, dann lasst euch davon nicht verwirren -> weiter im Programm ;) )
Und nun laufen lassen... ;)
Nun läuft es schonmal, d.h. es hat keine Fehler.
Als nächstes sollen Daten hinzugefügt werden können.
Dafür definieren wir den Typ T4ICQKontaktBuch um zum dynamischen Array.
Kleine Erinnerung: Eine Deklaration eines dynamisches Array ist einfach eine Array-Deklaration ohne Angabe
der Größe. Bisher haben wir fest hinterlegt, dass wir genau 4 Felder benötigt haben. Das kommt einfach weg ;)
Da ein dynamisches Array kein Dateityp sein kann, muss beim Laden und Speichern das "file of T4ICQKontaktBuch"
zu "file of TICQKontakt" geändert werden.
Damit wir es nachher auch gleich ausführen können, geben wir bei Read und Write einen pseudo-Array-Index an,
da wir ja mit Read und Write jetzt nur ein Element des Arrays speichern
und nicht mehr das ganze Array auf einmal (Bsp: Z. 61: Read(f,fICQKontaktBuch[0]); )
Nun erstellen wir die BtnNewClick-Methode (Doppelklick im Formular) in der folgendes gemacht werden muss:
- Sichern, falls es bereits ein Datensatz gibt, der verändert worden sein könnte
- Vergrößern des dynamischen Arrays fICQKontaktBuch,
- fCurrentIndex auf das letzte Element setzen,
- Da das Feld leer ist - alle Edits leeren,
- Da es evtl. das erste Mal ist, dass Daten geschrieben werden - alle Edits wieder Enabled := true
- BtnSaveFile wieder aktivieren, da ja mindestens jetzt Daten zum Speichern vorhanden sind.
Falls ich hier und da ein bisschen unklar war, was gemacht werden soll, hier kurz der Zwischenstand als
Source:
|
procedure TMainForm.BtnNewClick(Sender: TObject); begin // falls es bereits ein Datensatz gibt, der verändert worden sein könnte if (fCurrentIndex >= 0) and (fCurrentIndex <= High( fICQKontaktBuch)) then begin // Sichern: fICQKontaktBuch[fCurrentIndex].Nick := EdNick1.Text; fICQKontaktBuch[fCurrentIndex].Vorname := EdVorname1.Text; fICQKontaktBuch[fCurrentIndex].Nachname := EdNachname1.Text; fICQKontaktBuch[fCurrentIndex].UIN := StrToInt( EdIcqNummer1.Text); end; //Vergrößern des dynamischen Arrays fICQKontaktBuch SetLength( fICQKontaktBuch, Length( fICQKontaktBuch) + 1); // fCurrentIndex auf das letzte Element setzen, fCurrentIndex := High( fICQKontaktBuch); // Da das Feld leer ist - alle Edits leeren, EdNick1.Text := ''; EdVorname1.Text := ''; EdNachname1.Text := ''; EdIcqNummer1.Text := '0'; // Aufgrund IntToStr fürs Auslesen muss hier eine 0 stehen // Da es evtl. das erste Mal ist, dass Daten geschrieben werden -> Edits freigeben EdNick1.Enabled := true; EdVorname1.Enabled := true; EdNachname1.Enabled := true; EdIcqNummer1.Enabled := true; // BtnSaveFile wieder aktivieren, da ja jetzt Daten zum Speichern vorhanden sind. BtnSave.Enabled := true; end; |
Das Durchscrollen der hiermit erstellten Daten ist genauso einfach.
Hierzu müssen wir bei BtnPreviousClick lediglich ...
- die Felder wieder erstmal in die aktuelle Position im Array speichern,
- den Index runterzählen, sofern es weiter runter geht,
- die entsprechenden Werte aus dem Array in die Felder wieder eintragen,
- und den Status aktualisieren (das schließt auch ein, dass BtnPrevious und BtnNext deaktiviert werden, falls es kein weiteres Element im Array gibt).
Wieder - Das bedeutet, wir können das obige in eine Methode kapseln und auch wieder verwenden:
|
interface // ... type // ... TMainForm = class(TForm) // ... private { Private-Deklarationen } procedure FelderInsArray; //... implementation //... procedure TMainForm.FelderInsArray; begin // die Felder erstmal in die aktuelle Position im Array speichern fICQKontaktBuch[fCurrentIndex].Nick := EdNick1.Text; fICQKontaktBuch[fCurrentIndex].Vorname := EdVorname1.Text; fICQKontaktBuch[fCurrentIndex].Nachname := EdNachname1.Text; fICQKontaktBuch[fCurrentIndex].UIN := StrToInt( EdIcqNummer1.Text); end; |
Der Punkt mit dem Aufpassen ist auch wichtig, dass nicht außerhalb des Index-bereiches etwas ausgelesen
oder geschrieben wird.
Der Index-bereich eines dynamischen Arrays geht immer von 0 bis high(Array), jeweils inklusive.
Die Anleitung gilt nun für den "Zurück"-Button.
Wir können uns einfach auch den "Weiter"-Button ausdenken, indem wir die Logik leicht anpassen.
Das lass ich erstmal euch weiter denken, im folgenden könnt ihr den Beispiel-Code als Zwischenstand anzeigen
lassen.
Hier kurz mein Beispielcode zum "Weiter"-Button:
|
procedure TMainForm.BtnNextClick( Sender: TObject); begin FelderInsArray; if fCurrentIndex > 0 then begin fCurrentIndex := fCurrentIndex + 1; EdNick1.Text := fICQKontaktBuch[ fCurrentIndex].Nick; EdVorname1.Text := fICQKontaktBuch[ fCurrentIndex].Vorname; EdNachname1.Text := fICQKontaktBuch[ fCurrentIndex].Nachname; EdIcqNummer1.Text := IntToStr( fICQKontaktBuch[ fCurrentIndex].UIN); BtnPrevious.Enabled := fCurrentIndex > 0; BtnNext.Enabled := fCurrentIndex < High( fICQKontaktBuch); BtnSave.Enabled := BtnPrevious.Enabled; lblPos.Caption := IntToStr( fCurrentIndex + 1) + ' / ' + IntToStr( length( fICQKontaktBuch)); end; end; |
Mit den beiden Buttons geht das Scrollen durch die Daten nun perfekt.
Durchscrollen funktioniert also. Dann geht es um das wesentliche hier: das Speichern und Laden der Daten.
Beim Speichern müssen wir jedes Record speichern, also das ganze Array durchlaufen.
Hier bietet sich eine for-schleife an, welche von 0 bis zum letzten Index-Eintrag des Arrays hochzählt.
Im Schleifenrumpf können wir dann pro Datensatz die Write-Methode ausführt und so
das i-te Element des Arrays in die Datei schreiben.
Da wir für Aktualisierungen erstmal einen Button sparen möchten, werden wir beim Speichern den momentan aktiven
Datensatz auch gleich im Array aktualisieren.
Den Code dazu haben wir ja schon zum "wiederholten" Male.
|
{Click-Procedure des Buttons, der alles speichern soll: } procedure TMainForm.BtnSaveClick( Sender: TObject); var f : file of TICQKontakt; i: Integer; begin FelderInsArray; // Dateispeicherort wählen - hier ist es direkt im Verzeichnis, wo die // Exe-Datei gespeichert ist: AssignFile( f, ExtractFilePath( Application.Exename) + 'demofile.dat'); // da wir in diesem Fall "neu" speichern wollen, nutzen wir Rewrite() um // die Datei komplett zu leeren ReWrite( f); // nun schreiben wir unser Kontaktbuch in die Datei - Datensatz für Datensatz for i := 0 to High(fICQKontaktBuch) do begin Write( f, fICQKontaktBuch[ i]); end; // und zu guter Letzt, schließen wir den Zeiger auf die Datei. // das ermöglicht, dass ein anderes Programm auf die Datei zugreifen kann :) CloseFile( f); end; |
Das Laden ist etwas komplizierter, da wir nicht wissen, wie viele Elemente in der Datei gespeichert wurden.
Es bietet sich also eine while-Schleife an.
Wer möchte, kann nun versuchen, das Laden direkt zu programmieren.
Hier ist es ähnlich, wie beim Speichern. wir brauchen einen Zeiger auf die Datei um dann mit Read alles
auslesen zu können - Datensatz für Datensatz.
|
{ Click-Procedure des Buttons, der alles laden soll: } procedure TMainForm.BtnOpenClick(Sender: TObject); var f : file of TICQKontakt; begin // auch hier definieren wir erst den Zeiger auf die Datei AssignFile( f, ExtractFilePath( Application.Exename) + 'demofile.dat'); // nun stellen wir sicher, dass der Zeiger auf den Anfang zeigt ReSet( f); fCurrentIndex := -1; // Und jetzt lesen wir unser Kontaktbuch aus der Datei, // wieder Datensatz für Datensatz while not eof(f) do begin SetLength(fICQKontaktBuch, length(fICQKontaktBuch)+1); Inc(fCurrentIndex); Read( f, fICQKontaktBuch[ fCurrentIndex]); end; // Wie oben, alles wieder schließen CloseFile( f); // und die Anzeige aktualisieren StatusAnzeigen; ArrayInDieFelder; end; |
Und jetzt? Naja, wer ICQ-Nummern noch hat, kann hier wirklich was anfangen.
Alle Anderen, können das auch Nutzen um irgendetwas anderes zu speichern.
Dazu einfach die Felder entsprechend erweitern und anpassen.
Viel Spaß ;)
Viel Spaß ;)
Die Sources für dieses kleine Progrämmchen liegen unter
Github
zum Download bereit!
Viel Spaß :)
Viel Spaß :)