Ini-Writes global abfangen?

[Delphi-Laie]

Zitat von a.def:

Aufruf

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
var
 IniF: TMemIniFile;
begin
 IniF := TMemIniFile.Create(....., <irgendeine-boolsche-variable>);

 try
  IniF.WriteString('section', 'ident', 'value');
 finally
  IniF.UpdateFile; // wird nur wirklich ausgeführt, wenn die irgendeine-boolsche-variable true ist
  IniF.Free;
 end;
end;

Hallo a.def, just versuche ich, Dein Projekt nachzuvollziehen, doch ich verstehe es nicht recht. Ich nahm an, daß <irgendeine-boolsche-variable> dazu da ist, um festzustellen (zu "messen"), ob die Ini-Datei erstellt werden kann. Ergo müßte es egal sein, mit welchem booleschen Wert sie in diesen Konstruktor "eintaucht" (was allerdings mit der "const"-Deklaration keinen Sinn ergibt). Doch behält diese <irgendeine-boolsche-variable> ihren Wert nach dem Konstruktor "Create" unabhängig davon, ob in dieses Verzeichnis (die Ini-Datei) geschrieben werden kann oder nicht.

Wann wird denn <irgendeine-boolsche-variable> mit einem sinnvollen Wert gefüllt?

Danke und Gruß

Edit: Der Einwand mit dem const-Parameter war Unfug, ich nehme ihn zurück.

[DeddyH]

Das ist ein Parameter, der angibt, ob gespeichert werden soll und nicht, ob gespeichert werden kann.

[Delphi-Laie]

Zitat von DeddyH:

Das ist ein Parameter, der angibt, ob gespeichert werden soll und nicht, ob gespeichert werden kann.

Danke, Detlef! Das erhellt.

Gibt für mich zwar spontan keinen Sinn, denn Ini-Dateien sollen doch (eigentlich) immer gespeichert werden, sonst wären es doch keine (echten) Dateien, ohne Datenträger maximal noch Memory-Dateien, aber sei's drum, ich werde mich weiter damit beschäftigen.

[himitsu]

soll: es soll automatisch (bpätestens beim Free/Close gespeichert werden
kann: es sagt nicht aus, dass nicht dennoch später noch gespeichert werden könnte (Update)


Und was einen Sinn betrifft.

Wenn nichts gespeichert werden soll, warum werden dann überhaupt die Write-Funktionen aufgerufen, wenn doch eh nicht gespeichert werden soll?
Eingaben "wortlos" einfach so zu verwerfen ist eines der größten Fehlerpotentiale, die man in eine Komponente einbauen kann.

siehe TStrings.Objects ... ständigt wundert sich jemand, dass die Werte verschwinden, obwohl etwas zugewiesen wurde.
Eine Exception ala "Speichern/Objects nicht implementiert" hätte da sofort den Fehler aufgezeigt.

für mich ist soein Verhalten fast genauso schlimm wie ein try ... except end; im Code
und später heult dann jemand rum "mein Programm macht nie das, was ich will und ich weiß nicht warum ".

[Jumpy]

Er hat das doch schon ausführlich erklärt, dass es Konstellationen gibt, bei dem die INI-Datei schreibgeschützt ist und dann sollen die Werte halt nicht (zurück)geschrieben werden und anstatt jetzt an 23.345 Stellen im Code zu sagen If IniBeschreibbar then Ini.WriteString(...) wird das schreiben so an einer zentralen Stelle verhindert. Im Hinterkopf behalten: Es geht um TMemIni, d.h. das schreiben an sich funktioniert ja (in die In-Memory Ini), diese wird am Ende ggf. nur nicht wieder als Datei zurück geschrieben.

[himitsu]

Dann sollte die INI das aber auch sagen, wenn sie es nicht will.

Delphi-Quellcode:

uses
  SysUtils, IniFiles;

type
  TAccessIniFile = class(TMemIniFile)
  private
    FReadOnly: Boolean;
    procedure SetReadOnly(Value: Boolean);
  public
    constructor Create(const FileName: string; ReadOnly: Boolean=False); overload;

    procedure WriteString(const Section, Ident, Value: String); override;
    procedure DeleteKey(const Section, Ident: String); override;
    procedure EraseSection(const Section: string); override;
    procedure UpdateFile; override;

    property ReadOnly: Boolean read FReadOnly write SetReadOnly;
  end;

{ TAccessIniFile }

constructor TAccessIniFile.Create(const FileName: string; ReadOnly: Boolean);
begin
  inherited Create(FileName);
  FReadOnly := ReadOnly;
end;

procedure TAccessIniFile.DeleteKey(const Section, Ident: String);
begin
  if FReadOnly then
    raise Exception.Create('ReadOnly');
  inherited;
end;

procedure TAccessIniFile.EraseSection(const Section: string);
begin
  if FReadOnly then
    raise Exception.Create('ReadOnly');
  inherited;
end;

procedure TAccessIniFile.SetReadOnly(Value: Boolean);
begin
  if not FReadOnly and (FReadOnly <> ReadOnly) then
    UpdateFile;
  FReadOnly := ReadOnly;
end;

procedure TAccessIniFile.UpdateFile;
begin
  //if csDestroying in ComponentState then
  //  Exit;
  //if FReadOnly then
  //  raise Exception.Create('ReadOnly');
  //inherited;

  if not FReadOnly then
    inherited;
end;

procedure TAccessIniFile.WriteString(const Section, Ident, Value: String);
begin
  if FReadOnly then
    raise Exception.Create('ReadOnly');
  inherited;
end;

[a.def]

Zitat von Delphi-Laie:

Zitat von DeddyH:

Das ist ein Parameter, der angibt, ob gespeichert werden soll und nicht, ob gespeichert werden kann.

Danke, Detlef! Das erhellt.

Gibt für mich zwar spontan keinen Sinn, denn Ini-Dateien sollen doch (eigentlich) immer gespeichert werden, sonst wären es doch keine (echten) Dateien, ohne Datenträger maximal noch Memory-Dateien, aber sei's drum, ich werde mich weiter damit beschäftigen.

Habe das AutoSave ja jetzt eh durch ReadOnly ausgetauscht. Die Funktionalität ist also etwas anders.

Zitat:

Dann sollte die INI das aber auch sagen, wenn sie es nicht will.

Tut mein Programm doch ganz zu Anfang

Hier meine aktuelle Unit. Den Parameter "AutoSave" gibt es nicht mehr. Stattdessen werden Write-Befehle nicht ausgeführt, wenn ReadOnly True ist.

Delphi-Quellcode:

unit classIni;

interface

uses
 SysUtils, IniFiles;

type
 TMemIniFile = class(IniFiles.TMemIniFile)

 private
  FModified, FReadOnlyMode: Boolean;
  function IsNumeric(const aString: string; const bAcceptNegativeNumbers: Boolean = True): Boolean;
  procedure FlushModifications;
 public
  constructor Create(const FileName: string; const ReadOnlyMode: Boolean = False); overload;
  constructor Create(const FileName: string; const Encoding: TEncoding; const ReadOnlyMode: Boolean = False); overload;
  destructor Destroy; {* reintroduce; *} override;
  procedure UpdateFile; override;

  procedure WriteString(const Section, Ident, Value: string); reintroduce; overload;
  procedure WriteInteger(const Section, Ident: string; Value: Integer); reintroduce; overload;
  procedure WriteBool(const Section, Ident: string; Value: Boolean); reintroduce; overload;

  function ReadInt64(const Section, Ident: string; Default: Int64): Int64;
  procedure WriteInt64(const Section: string; const Ident: string; Value: Int64);
 end;

implementation

// Helper
// ==============================================================================================================================================
function TMemIniFile.IsNumeric(const aString: string; const bAcceptNegativeNumbers: Boolean = True): Boolean;
var
 bRes: Boolean;
begin
 bRes := StrToInt64Def(aString, 0) = StrToInt64Def(aString, 1);

 if bRes and (not bAcceptNegativeNumbers) and (StrToInt64(aString) < 0) then
  bRes := False;

 Result := bRes;
end;

procedure TMemIniFile.FlushModifications;
begin
 // Flush the modifications to disk
 if (not FReadOnlyMode) and FModified then
  begin
   inherited UpdateFile;

   FModified := False;
  end;
end;
// ==============================================================================================================================================

// Create / Update
// ==============================================================================================================================================
constructor TMemIniFile.Create(const FileName: string; const ReadOnlyMode: Boolean = False);
begin
 inherited Create(FileName);

 FReadOnlyMode := ReadOnlyMode;
 FModified := False;
end;

constructor TMemIniFile.Create(const FileName: string; const Encoding: TEncoding; const ReadOnlyMode: Boolean = False);
begin
 inherited Create(FileName, Encoding);

 FReadOnlyMode := ReadOnlyMode;
 FModified := False;
end;

destructor TMemIniFile.Destroy;
begin
 // If not already flushed to disk, flush modifications now
 FlushModifications;

 inherited Destroy;
end;

procedure TMemIniFile.UpdateFile;
begin
 // Flush the modifications to disk
 FlushModifications;
end;
// ==============================================================================================================================================

// Writes / Reads
// ==============================================================================================================================================
procedure TMemIniFile.WriteString(const Section, Ident, Value: string);
begin
 if not FReadOnlyMode then
  begin
   inherited WriteString(Section, Ident, Value);

   FModified := True;
  end;
end;

procedure TMemIniFile.WriteInteger(const Section, Ident: string; Value: Integer);
begin
 WriteString(Section, Ident, IntToStr(Value));
end;

procedure TMemIniFile.WriteBool(const Section, Ident: string; Value: Boolean);
const
 Values: array [Boolean] of string = ('0', '1');
begin
 WriteString(Section, Ident, Values[Value]);
end;

function TMemIniFile.ReadInt64(const Section: string; const Ident: string; Default: Int64): Int64;
var
 sTmp: string;
begin
 sTmp := ReadString(Section, Ident, SysUtils.IntToStr(Default));

 if IsNumeric(sTmp, True) then
  Result := StrToInt64(sTmp)
 else
  Result := Default;
end;

procedure TMemIniFile.WriteInt64(const Section: string; const Ident: string; Value: Int64);
begin
 WriteString(Section, Ident, SysUtils.IntToStr(Value));
end;
// ==============================================================================================================================================

end.

[DeddyH]

Zitat:

destructor Destroy; reintroduce; override;

Wozu das reintroduce?

[a.def]

War noch ein Überbleibsel von gestern, muss natürlich weg. Gestern hatte ich das Problem, dass der Destruktor gar nicht erst aufgerufen wurde. Ist jetzt aber behoben.