File of eigener Typ

[eragon123]

Mein Problem: ich will eine Art Verwaltungsprogramm schreiben, welches Daten zu einer Reihe gelesener Bücher speichert. Dabei ergeben sich 2 Probleme bei der Speicherung dieser Daten:
1: ich habe für die Daten der Bücher einen eigenen REcord geschrieben und wenn ich das jetzt in einem File speichern will meckert der Compiler... was tun?

Delphi-Quellcode:

TNote = 1..6;

  buch = record
  Titel: string[50];
  Autor: string[50];
  Erscheinungsjahr: TDate;
  DatumEintrag: TDate;
  ISBN: Integer;
  Bewertung: TNote;
  Kommentar: string[100];
  Privat: Boolean;
  end;

  TBuecherliste = array of buch;

// ....

Datei: file of TBuecherliste; // Fehler

Fehler: Type 'TBuecherliste' needs finalization...

2: Diese Datei soll auf einer zentralen Festplatte im Netzwerk liegen, auf die verschiedenen User mit diesem Programm zugreifen. Wie kann ich erkenne ob die Datei gerade genutzt wird? Denn mehrere Nutzer können ja nicht gleichzeitig in eine Datei schreiben oder?

[mkinzler]

Delphi-Quellcode:

Datei: file of  TBuch;

Denn du willst ja Bücher und keine Bücherlisten speichern.
Da TBuecherliste ein dynamische Array ist, kann den Speicherbedarf nicht ermittelt werden

[eragon123]

OK danke... Denkfehler... ich kann ja trotzdem mehrere Datensätze reinschreiben. Doch jetzt meckert er bei öffnen der Datei:

Delphi-Quellcode:

Buecher: array of buch;

procedure TForm1.datenladen;  // Alle Daten aus der Datei einlesen
var I: Integer;
begin
  AssignFile(Datei,speicherort);              // Datei anlegen
  Reset(Datei);
  SetLength(Buecher,0);                       // Bücher zurücksetzen
  i := 0;

  while not Eof(Datei) do                     // Daten einlesen
  begin
    SetLength(Buecher,Length(Buecher)+1);
    Readln(Datei,Buecher[i]);
    Inc(i);
  end;

  CloseFile(Datei);
end;

Beim assign meckert er incompatible types und später beim schreiben auch.

[mkinzler]

Ist Datei genauso deklariert?
ReadLn() funktioniert nur bei Textdateien ( TextFile)

[Klaus01]

Guten Abend,

ist im Speicherort auch der Name der Datei enthalten, oder nur der Pfad?

Zitat:

Zitat von eragon123

Delphi-Quellcode:

  while not Eof(Datei) do                     // Daten einlesen
  begin
    SetLength(Buecher,Length(Buecher)+1);
    Readln(Datei,Buecher[i]);
    Inc(i);
  end;

  CloseFile(Datei);
end;

Noch eine Anmerkung zu Setlength, es ist schneller und auch besser (wegen der Speicherzuordnung)
SetLength nicht in Schritten von 1 zu erhöhen.
Setze SetLength auf einen größeren Wert und prüfe wenn Du das Array füllst
ob das Array bereits komplett gefüllt ist wenn ja vergrößerst Du es wieder.

Eventuell würde ich auch über TList nachdenken.

Grüße
Klaus

Grüße
Klaus

[eragon123]

Ja das ist so deklariert. Das mit dem setlength merk ich mir danke ;). Hier einfach mal der gesamt bisherige Text.

Delphi-Quellcode:

unit mMain;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs;

type
  TNote = 1..6;

  buch = record
  Titel: string[50];
  Autor: string[50];
  Erscheinungsjahr: TDate;
  DatumEintrag: TDate;
  ISBN: Integer;
  Bewertung: TNote;
  Kommentar: string[100];
  Privat: Boolean;
  end;

  TBuecherliste = array of buch;

  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
  private
    { Private declarations }
    procedure datenladen;
    procedure datenspeichern;
    procedure datenzeigen(SortiertNach: string);
    procedure encrypt(schluessel: string);
    procedure decrypt(schluessel: string);
    procedure neuerWert;
    procedure WertLoeschen;
    procedure WertAendern();
    function benutzer: Boolean;
    function passwort: Boolean;
    function speicherort: Boolean;

  public
    { Public declarations }
  end;

var
  Form1: TForm1;
  Buecher: array of buch;
  passwort: string;
  benutzer: string;
  speicherort: string;
  Datei: file of buch;

implementation

{$R *.dfm}



procedure TForm1.datenladen;  // Alle Daten aus der Datei einlesen
var I: Integer;
begin
  AssignFile(Datei,speicherort);              // Datei anlegen // FEHLER hier 
  Reset(Datei);
  SetLength(Buecher,0);                       // Bücher zurücksetzen
  i := 0;

  while not Eof(Datei) do                     // Daten einlesen
  begin
    SetLength(Buecher,Length(Buecher)+1);
    Read(Datei,Buecher[i]);
    Inc(i);
  end;

  CloseFile(Datei);
end;

procedure TForm1.datenspeichern;     // Alle Daten speichern
var I: Integer;
begin
  AssignFile(Datei,speicherort);              // Datei anlegen  // FEHLER HIER
  Rewrite(Datei);
  i := 0;

  while not Eof(Datei) do                     // Daten schreiben
  begin
    Writeln(Datei,Buecher[i]);         // FEHLER HIER
    Inc(i);
  end;

  CloseFile(Datei);
end;

procedure TForm1.datenzeigen(SortiertNach: string);
begin

end;

procedure TForm1.decrypt(schluessel: string);
begin

end;

procedure TForm1.encrypt(schluessel: string);
begin

end;

procedure TForm1.FormCreate(Sender: TObject);
var clickedok: Boolean;
begin
  // Sachen abfragen
end;


procedure TForm1.neuerWert;
begin

end;

function TForm1.passwort: Boolean;    // Passwort erfragen
begin
  Result := InputQuery('Eingabe','Benutzernamen eingeben',passwort); // Wenn ok gedrückt wird = true; bei abbrechen false
end;

function TForm1.speicherort: Boolean; // Speicherort erfragen
begin
  Result := InputQuery('Eingabe','Benutzernamen eingeben',speicherort);
end;

function TForm1.benutzer: Boolean;   // Benutzer erfragen
begin
  Result := InputQuery('Eingabe','Benutzernamen eingeben',benutzer);
end;

procedure TForm1.WertAendern;
begin

end;

procedure TForm1.WertLoeschen;
begin

end;

end.

[Klaus01]

Delphi-Quellcode:

function speicherort: Boolean;

und

Delphi-Quellcode:

AssignFile(Datei,speicherort);

Passt nicht so ganz, oder?

Grüße
Klaus

[Teekeks]

Und mach auch bei dem Writeln das ln weg, dann kommt da kein Fehler mehr :)

[eragon123]

Ah ok Speicherort gibts als Funktion und als String... danke ;-).
Jetzt gehts... erstmal^^.

[himitsu]

Zitat:

Zitat von eragon123

Ah ok Speicherort gibts als Funktion und als String... danke ;-).
Jetzt gehts... erstmal^^.

Jupp, und da die Funktion als Methode in der Klasse näher zu datenladen deklariert ist, wird dieses natürlich an dieser Stelle bevorzugt.


Das ist auch einer der Gründe, warum man keine globalen Variablen verwenden soll.

a) hätte hier der Compiler die doppelten Namen entdeckt und gemeckert
b) ist vorallem die Datei eine lokale Variable, welche nur in datenladen
verwendet wird (dort initialisiert und auch freigegeben) ... sowas gehört auch nur lokal und hat absolut nix global zu suchen :warn:
(genauso wie das I, wobei dort bestimmt der Compiler gemeckert hat ... oder warum ist Diese mal zur Abwechslung lokal deklariert? )

Delphi-Quellcode:

  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
  private
    { Private declarations }
    Buecher: array of buch;
    passwort: string;
    benutzer: string;
    speicherort: string;
    procedure datenladen;
    procedure datenspeichern;
    procedure datenzeigen(SortiertNach: string);
    procedure encrypt(schluessel: string);
    procedure decrypt(schluessel: string);
    procedure neuerWert;
    procedure WertLoeschen;
    procedure WertAendern();
    function benutzer: Boolean;
    function passwort: Boolean;
    function speicherort: Boolean;
  public
    { Public declarations }
  end;

implementation

{$R *.dfm}

procedure TForm1.datenladen;  // Alle Daten aus der Datei einlesen
var I: Integer;
  Datei: file of  buch;
begin
  AssignFile(Datei,speicherort);              // Datei anlegen // FEHLER hier
  Reset(Datei);
  SetLength(Buecher,0);                       // Bücher zurücksetzen
  i := 0;

  while not Eof(Datei) do                     // Daten einlesen
  begin
    SetLength(Buecher,Length(Buecher)+1);
    Read(Datei,Buecher[i]);
    Inc(i);
  end;

  CloseFile(Datei);
end;

Mal so als Frage: Wer hat dir denn beigebracht, so daß du die ganzen Variablen global neben dem Form1 abgelegt hast? (gib demjenigen bitte mal 'ne Ohrfeige und schick ihn/sie hier bei uns vorbei)

[Chemiker]

Hallo eragon123,

für die Deklaration des Records sollte man, wenn man in speichert mit packed arbeiten. In Deinen Beispiel würde man 7Byte pro Datensatz sparen.

Also der Record sollte so aussehen:

Delphi-Quellcode:

buch = packed record 
  Titel: string[50]; 
  Autor: string[50]; 
  Erscheinungsjahr: TDate; 
  DatumEintrag: TDate; 
  ISBN: Integer; 
  Bewertung: TNote; 
  Kommentar: string[100]; 
  Privat: Boolean; 
end;

Zudem ist eine Fehlerbehandlung bei I/O-Operationen auch nicht verkehrt(eigentlich zwingend notwendig).

Bis bald Chemiker

[himitsu]

Zitat:

Zitat von Chemiker

für die Deklaration des Records sollte man, wenn man in speichert mit packed arbeiten.

Sowas sollte man eh immer machen, sobald Daten übertragen oder gespeichert werden sollen,
also sobald Daten den Prozess/die Programminstanz, das Modul (EXE/DLL) verlassen.

Ebenso sollte man nur statische Typen nehmen.

z.B. Integer und Char können sich ja schnell mal in der nächsten Delphi-/Compilerversion verändern
(ein gutes Beispiel sind die vielen Unicode-Probleme mit alten Programmen/Codes, seit Delphi 2009)

Zitat:

Zitat von Chemiker

In Deinen Beispiel würde man 7Byte pro Datensatz sparen.

Aber dennoch würde ich eine "ordentliche" Speicherausrichtung nicht übergehen und hierbei manuell für die

Delphi-Quellcode:

TNote = 1..6;
TBuch = packed record                             8 Byte-Align    4 Byte
  Titel: String[51];               //  52 Byte =  6,5  > 6,5   = 13   >13
  Autor: String[51];               //  52 Byte =  6,5  >13     = 13   >26
  Erscheinungsjahr: TDate;         //   8 Byte =  1    >14     =  2   >28
  DatumEintrag: TDate;             //   8 Byte =  1    >15     =  2   >30
  ISBN: LongInt;                   //   4 Byte =  0,5  >15,5   =  1   >31
  Kommentar: String[105{oder 97}]; // 106 Byte = 13,25 >28,75  = 26,5 >57,5
  Bewertung: TNote;                //   1 Byte =  0,125>28,875 =  0,25>57,75
  Privat: Boolean;                 //   1 Byte =  0,125>29     =  0,25>58
end;

Für 'nen 32-Bit-Prozess also eine passende Ausrichtung.

[Progman]

Hier mal eine effektivere Variante zum Einlesen:

Delphi-Quellcode:

procedure LoadArray;  // Datei öffnen
var
  i, anzahl: Integer;
  f: TFileStream;
begin
  if FileExists(Path+OpenName) then begin //Path und OpenName sind Verzeichnis und Dateiname
    try
      f := TFileStream.Create(Path+OpenName, fmOpenRead)
    except
      ShowMessage('Die Datei konnte nicht geöffnet werden!');
      Exit;
    end;
    f.ReadBuffer(Anzahl, SizeOf(Integer)); //anzahl wird hier mit der Anzahl der Records geladen
    SetLength(MeinArray, Anzahl); //und kann direkt für SetLenghth genutzt werden
    for i := 0 to Anzahl-1 do f.ReadBuffer(MeinArray[i],SizeOf(TMeinRec)); // alle Records einlesen
    f.Free;
  end;
end;

Array und Record müssen natürlich angepasst werden. Ich hab das mal eben aus einer Anwendung von mir rauskopiert :-)

[himitsu]

effktiver =

Delphi-Quellcode:

f.ReadBuffer(MeinArray[0],SizeOf(TMeinRec) * Anzahl); // alle Records einlesen

noch was zur Fehlerbehandlung:
- TFileStream.Create gibt schon eine gute Fehlermeldung aus ... diese muß ja nicht unbedingt zerstören
- und was passiert mit "f", wenn ReadBuffer oder SetLength eine Exception werfen?

Delphi-Quellcode:

if FileExists(Path+OpenName) then begin //Path und OpenName sind Verzeichnis und Dateiname
  f := TFileStream.Create(Path+OpenName, fmOpenRead)
  try
    f.ReadBuffer(Anzahl, SizeOf(Integer)); //anzahl wird hier mit der Anzahl der Records geladen
    SetLength(MeinArray, Anzahl); //und kann direkt für SetLenghth genutzt werden
    f.ReadBuffer(MeinArray[0],SizeOf(TMeinRec) * Anzahl); // alle Records einlesen
  finally
    f.Free;
  end; 
end
else
  raise Exception.CreateFmt('Datei "%s" existiert nicht.', [OpenName]);

oder

Delphi-Quellcode:

if FileExists(Path+OpenName) then begin //Path und OpenName sind Verzeichnis und Dateiname
  f := TFileStream.Create(Path+OpenName, fmOpenRead)
  try
    Anzahl := f.Size div SizeOf(TMeinRec); // Anzahl wird aus der Dateigröße berechnet
    SetLength(MeinArray, Anzahl); //und kann direkt für SetLenghth genutzt werden
    f.ReadBuffer(MeinArray[0], SizeOf(TMeinRec) * Anzahl); // alle Records einlesen
  finally
    f.Free;
  end; 
end
else
  raise Exception.CreateFmt('Datei "%s" existiert nicht.', [OpenName]);

[Progman]

Das war auch nur ganz flüchtig rauskopiert.
Mir ging es eigentlich nur darum, dieses (sehr uneffektive) schrittweise SetLength zu eliminieren :-)

[Chemiker]

Hallo himitzu,

Zitat:

Zitat von himitzu

Aber dennoch würde ich eine "ordentliche" Speicherausrichtung nicht übergehen und hierbei manuell für die

Delphi-Quellcode:

TNote = 1..6;
TBuch = packed record                             8 Byte-Align    4 Byte
  Titel: String[51];               //  52 Byte =  6,5  > 6,5   = 13   >13
  Autor: String[51];               //  52 Byte =  6,5  >13     = 13   >26
  Erscheinungsjahr: TDate;         //   8 Byte =  1    >14     =  2   >28
  DatumEintrag: TDate;             //   8 Byte =  1    >15     =  2   >30
  ISBN: LongInt;                   //   4 Byte =  0,5  >15,5   =  1   >31
  Kommentar: String[105{oder 97}]; // 106 Byte = 13,25 >28,75  = 26,5 >57,5
  Bewertung: TNote;                //   1 Byte =  0,125>28,875 =  0,25>57,75
  Privat: Boolean;                 //   1 Byte =  0,125>29     =  0,25>58
end;

Für 'nen 32-Bit-Prozess also eine passende Ausrichtung.

damit ist der Record doch genauso groß wie der vom Beitragsersteller ohne packed.
Zudem ist man teilweise an die Größe von Feldern gebunden. Für eine deutsche PLZ braucht man nicht mehr als 5 Stellen(es sei denn wir kaufen demnächst Griechenland und Spanien usw.).

Bis bald Chemiker

[himitsu]

Man kann die Werte ja nach unten runden (bei 32 Bit reicht es ja auch, wenn man auf 4 Byte ausrichtet)

Füllfelder und eine andere Anorfnung der Felder machen schon viel aus, aber nja
Hauptsache ist ja, daß man bei sowas Packed und feste Typen verwendet und der Rest ist Optimierungssache, welche man notfalls auch mal weglassen kann wenn es einem nicht so wichtig ist. :stupid: