FileStream mit "TIniFile Funktionalität".Methoden

[Bjoerk]

Ich würde gerne eine FileStream Klasse schreiben die ich wie eine IniFile behandeln kann. Wie könnte man denn sowas machen? Ich habe gedacht daß ich einen Header anlege in der ich die nötigen Infos speichere. Nur, wie könnte so ein Header aussehen? Oder ist das Ganze Blödsinn?

[Sir Rufo]

Du willst eine Klasse von

Delphi-Quellcode:

TFileStream

ableiten und dann um Methoden von

Delphi-Quellcode:

TIniFile

erweitern?

Lass mich kurz überlegen: Ja, das ist Blödsinn :)

[Bjoerk]

Juut. Einverstanden. :oops:

Dann anders rum. Wie krieg ich eine emf in eine IniFile. Auch Blödsinn?

[Sir Rufo]

Zitat:

Zitat von Bjoerk (Beitrag 1260264)

Juut. Einverstanden. :oops:

Dann anders rum. Wie krieg ich eine emf in eine IniFile. Auch Blödsinn?

Nö, du bekommst quasi alles in ein IniFile mit TiniFile.WriteBinaryStream ;)

[DeddyH]

Meintest Du vielleicht eher TIniFile.WriteBinaryStream?

[Bjoerk]

Okay. Wenn das funktioniert? Wäre mir ja auch viel lieber. Ich werf mal einen Blick in die inifiles.pas. Melde mich ggf. nochmal. Thanx!

[himitsu]

TCustomIni (der Vorfahre von TIniFile) ... das kann man gern verwenden und ihm, statt der INI-Datei-WinAPI, ein anderes Backend verpassen.
TStringListe mit Names/Values (ist wie eine INI, aber mit nur einer einzigen Section)
TStringStream
TTextReader
TTextWriter
TBinaryReader
TBinaryWriter
TStringReader
TStringWriter
TStreamWriter
TStreamReader
...


Das Read, ReadLn, Write und WriteLn des alten AssignFile

[Bjoerk]

Okay. Ich hab's jetzt erst mal so probiert. Funzt einwandfrei.

Delphi-Quellcode:

function TMemIniFileEx.ReadMetaFile(const Section, Name: string;
  Value: TMetaFile): integer;
var
  MemoryStream: TMemoryStream;
begin
  MemoryStream := TMemoryStream.Create;
  try
    Result := ReadBinaryStream(Section, Name, MemoryStream); // integer, kein int64
    MemoryStream.Position := 0;
    Value.LoadFromStream(MemoryStream);
  finally
    MemoryStream.Free;
  end;
end;

procedure TMemIniFileEx.WriteMetaFile(const Section, Name: string;
  Value: TMetaFile);
var
  MemoryStream: TMemoryStream;
begin
  MemoryStream := TMemoryStream.Create;
  try
    Value.SaveToStream(MemoryStream);
    MemoryStream.Position := 0;
    WriteBinaryStream(Section, Name, MemoryStream);
  finally
    MemoryStream.Free;
  end;
end;

[Sir Rufo]

Bis auf die Tatsache, dass du dich jetzt mit einem

Delphi-Quellcode:

TMemIniFile

verheiratet hast sieht das doch gut aus.

Wenn du eine Klasse geschrieben hättest, die etwas näher bei deiner Anwendung und etwas weiter weg von

Delphi-Quellcode:

TMemIniFile

ist, dann wäre das flexibler.

Delphi-Quellcode:

type
  TFoo = class( TCustomIniFile )
  private
    FIniFile : TCustomIniFile;
  public
    constructor Create( AIniFile : TCustomIniFile );

    // Alle Methoden auf die interne FIniFile umleiten

    procedure WriteMetaFile( const Section, Name : string; const Value : TMetaFile );
    procedure ReadMetaFile( const Section, Name : string; const Value : TMetaFile );
  end;

constructor TFoo.Create( AIniFile : TCustomIniFile );
begin
  inherited Create;
  if not Assigned( AIniFile ) 
  then
    raise EArgumentNilException.Create( 'TFoo: AIniFile' );
  FIniFile := AIniFile;
end;

procedure TFoo.WriteMetaFile( const Section, Name : string; const Value : TMetaFile );
var
  LStream : TStream;
begin
  LStream := TMemoryStream.Create;
  try
    Value.WriteToStream( LStream );
    LStream.Position := 0;
    FIniFile.WriteBinaryStream( Section, Name, LStream );
  finally
    LStream.Free;
  end;
end;

[Bjoerk]

Okay. Meistens arbeite ich aber mit einen eigenen IniFileParser. Der liest die Ini mit Assignfile und Co als TextFile ein. Wenn ich dort jetzt die Methoden (ReadMetaFile, ReadBinaryStream bzw. WriteMetaFile, SaveToStream) ergänze geht das dann noch als TextFile?

Delphi-Quellcode:

function TStrIniFile.LoadFile: boolean;
var
  F: TextFile;
  S: string;
  Buf: array [1..65536] of Char;
begin
  Result := false;
  if IniFileExists then
  begin
    AssignFile(F, FFileName);
    SetTextBuf(F, Buf);
    if CanOpenFile(F, false) then
    begin
      while not Eof(F) do
      begin
        Readln(F, S);
        if IsIniLine(S) then
          AddItem(S);
      end;
      CloseFile(F);
      Result := true;
    end;
  end;
end;

function TStrIniFile.SaveFile: boolean;
var
  F: TextFile;
  I: integer;
  Buf: array [1..65536] of Char;
begin
  Result := false;
  if FFileName <> '' then
  begin
    AssignFile(F, FFileName);
    SetTextBuf(F, Buf);
    if CanOpenFile(F, true) then
    begin
      for I := 0 to FCount - 1 do
      begin
        if I > 0 then
          if FEqualSignPos[I] < 0 then
            Writeln(F);
        Writeln(F, FItems[I]);
      end;
      CloseFile(F);
      Result := true;
    end;
  end;
end;

[Sir Rufo]

Zitat:

Zitat von Bjoerk (Beitrag 1260303)

Okay. Meistens arbeite ich aber mit einen eigenen IniFileParser. Der liest die Ini mit Assignfile und Co als TextFile ein. Wenn ich dort jetzt die Methoden (ReadMetaFile, ReadBinaryStream bzw. WriteMetaFile, SaveToStream) ergänze geht das dann noch als TextFile?

:shock: Das macht Sinn? Das musst du mir aber jetzt mal erklären, warum du nicht einfach TIniFile benutzt

[Bjoerk]

Ist das verboten? Zum Beispiel weil IniFile bei jedem Wert neu abspeichert? Weil meiner schneller und umfangreicher ist? BTW, hab gesehen daß WriteBinaryStream BinToHex umwandelt. Also no Problem mit AssignFile und Co..

[Neutral General]

Zitat:

Zitat von Bjoerk (Beitrag 1260316)

Ist das verboten? Zum Beispiel weil IniFile bei jedem Wert neu abspeichert? Weil meiner schneller und umfangreicher ist? BTW, hab gesehen daß WriteBinaryStream BinToHex umwandelt. Also no Problem mit AssignFile und Co..

Es gibt eine TMemIniFile in der IniFiles.pas, die Speichert nicht jedes mal direkt auf die Platte.
(und ist daher ggf. auch schneller).

Und brauchst du wirklich eine High-Speed Ini? Wenn du so viel/oft in eine Ini schreibst oder daraus liest dann solltest du wahrscheinlich eh über Alternativen nachdenken weil eine Ini keine Datenbank ist.

Wenn es nur ab und zu mal (beim Programmstart und vllt beim Ändern irgendwelcher Einstellungen) passiert dann machen auch 100ms nix aus ;)

[himitsu]

Zitat:

Zitat von Bjoerk (Beitrag 1260295)

Okay. Ich hab's jetzt erst mal so probiert. Funzt einwandfrei.

Delphi-Quellcode:

function TMemIniFileEx.ReadMetaFile(const Section, Name: string;
  Value: TMetaFile): integer;
var
  MemoryStream: TMemoryStream;
begin
  MemoryStream := TMemoryStream.Create;
  try
    Result := ReadBinaryStream(Section, Name, MemoryStream); // integer, kein int64
...

Wobei ich hier mich etwas wundere.

Wollte man nun ein TIniFile, was nicht mit einer Datei, sondern auf einem Stream arbeitet (für den gesamten Inhalt der INI), so wie es im Titel heißt,
oder wollte man einen Stream in einem INI-Value abspeichern, so wie es in diesem Code gemacht wird?

Zitat:

Zum Beispiel weil IniFile bei jedem Wert neu abspeichert? Weil meiner schneller

TMemIniFile


Man kann natürlich auch überlegen, ob man unbedingt eine INI verwenden muß, oder ob ein anderes Daten-/Dateiformat nicht auch ginge.

[Bjoerk]

Genau so ist es, Michael. Eigentlich mißbrauche ich IniFiles als Datenbank. Das kann ich auf die Schnelle aber nicht ändern. :oops:

[Bjoerk]

Zitat:

Wobei ich hier mich etwas wundere.

Wollte man nun ein TIniFile, was nicht mit einer Datei, sondern auf einem Stream arbeitet (für den gesamten Inhalt der INI), so wie es im Titel heißt,
oder wollte man einen Stream in einem INI-Value abspeichern, so wie es in diesem Code gemacht wird?

Ganz recht Himitsu. Sir Rufo ist "Schuld". :-D -> Siehe #2.

[himitsu]

Zitat:

Zitat von Bjoerk (Beitrag 1260321)

Eigentlich mißbrauche ich IniFiles als Datenbank. Das kann ich auf die Schnelle aber nicht ändern. :oops:

Doch. :mrgreen:


Du nimmst dir TCustomIniFile, baust als Backend den Zugriff auf die Datenbank ein und im Programm wird das Ding dann wie ein TIniFile verwendet ... schreibt und liest aber in Wirklichkeit in die/aus der Datenbank.

PS: Das gibt es auch schon, siehe TRegIniFile, welches wie eine TIniFile aussieht, aber in Wirklichkeit die Daten in einem RegistryPfad speichert.
Danach kann man dann in Ruhe und Schrittweise die Funktionen direkt auf die DB umstellen, ohne daß der restliche alte Code gleich knallt.

Das ist einer der Vorteile der OOP ... kompatible Schnittstelle aber dahinter liegt eine unterschiedliche Funktion.

[Bjoerk]

Stimmt. Gute Idee. Die Lese und Schreibzugriffe Klassenintern an eine Datenbank delegieren (private FDatenbank: TDatenbank). Welche würde sich denn für diesen Zweck anbieten (Client Server brauch ich nicht)?

[Neutral General]

Firebird Embedded oder SQLite würde ich sagen

[DeddyH]

Prinzipiell kannst Du da jede DB nehmen, die Embedded-Modus, also ohne Serverinstallation, unterstützt (Firebird Embedded, SQLite, Absolute Database, etc.).