Ini ohne IniFiles Project (WinApi)

[KodeZwerg]

Wie der Titel bereits besagt, Ini Support ohne IniFiles Unit zu verwenden, komplett auf WinApi Methoden aufgebaut.
Sinn und Zweck: Hauptsächlich gut für kleine NonVcl oder Konsolen Projekte die nicht viel Ini Funktionalität benötigen.

Status: Finale Beta

Der aktuelle Stand der Dinge:

Delphi-Quellcode:

(*
Achtung:
Diese Unit nicht in "Verkaufssoftware" verwenden. Nehmt original IniFiles Unit und gut ist.
Diese Unit ist gut für kleine NonVcl oder Konsolen Projekte geeignet die keine so umfangreiche Ini abdeckung brauchen.

Obwohl ich alles getestet habe, besteht immer die Gefahr das etwas nicht so funktioniert wie vorhergesehen!

Für mich ist es ein Forschungsprojekt um zu sehen wie Windows arbeitet und wieviel Bytes man sparen kann.
Ziel war es lediglich die Windows Unit einbinden zu müssen um Ini-Support zu ermöglichen.

erstellt im Sommer 2020 von KodeZwerg

Neuerungen:
Alle default Werte verworfen.
Umstellung von Class auf Record typ.
Code refactored.
properties erstellt um die art des aufrufs abzukürzen.
SmallestBuild direktive um lediglich strings lesen/schreiben zu können,
so kann jeder auf seine gewohnte RTL zurückgreifen.

Es sollte alles sauber funktionieren solange der Input passt.

Wer sichergehen möchte das alles wie erwartet reibungslos funktioniert,
dem Empfehle ich sich auf Read-/WriteString() bei Benutzung zu beschränken
und in der Projekt-Unit selbst eine Datenumwandlung vom/zum String-typ einzupflegen.
(zBsp ist bei mir ein Boolean entweder '1' oder '0' und nicht 'True' oder 'False'
 bzw alles was nicht '0' ist, entspricht 'True')
(In diesen Zusammenhang ist die direktive SmallestBuild recht nützlich.)


Danke an himitsu für den record Vorschlag anstelle einer Klassen-Nutzung!
Danke an himitsu für ein ReadString Beispiel ohne mehrere Variablen in Benutzung zu haben!

Lizenz: OpenSource ohne ein Lizenzmodell oder Beschränkungen jeglicher Art.
Haftung: keine, Benutzung auf Eigene Gefahr.

Kurzanleitung:
bindet diese Unit ein, gebt einer Variablen in Eurem Projekt als Datentyp TkzIni an.
Als Beispiel: var Ini: TkzIni;
ab nun kann man über diese variable ini dateien ansprechen und bearbeiten.
Als Beispiel:
TestString := Ini.ReadString('Pfad:\Dateiname.ini', 'Optionen', 'OptionsName', 'OptionsGrundwert');
je mehr properties man setzt umso kürzer wird der letztendliche aufruf,
siehe folgendes Beispiel.
so könnte man vorgehen, wenn man mehrere dinge auslesen möchte.
Ini.FileName := 'Pfad:\Dateiname.ini';
Ini.Section := 'Optionen';
TestString := Ini.ReadString('OptionsName', 'OptionsGrundwert');
TestInteger := Ini.ReadInteger('IntegerName', 42);
*)

unit kzIniFiles;

{.$DEFINE SmallestBuild}

interface

type
  TkzIni = record
{$IFNDEF SmallestBuild}
  private
    { Properties }
    FFileName: string;
    FSection: string;
    FIdent: string;
    { Datentypumwandlungshelfer }
    function _IntToStr(const Value: Integer): string;
    function _StrToInt(const Value: string): Integer;
    function _BoolToStr(const Value: Boolean): string;
    function _StrToBool(const Value: string): Boolean;
    function _FloatToStr(const Value: Real): string;
    function _StrToFloat(const Value: string): Real;
{$ENDIF SmallestBuild}
  public
    { Basis funktionalität, alle anderen methoden nutzen diese intern }
    function ReadString(const FileName, Section, Ident, Default: string): string; overload;
    function WriteString(const FileName, Section, Ident, Value: string): Boolean; overload;
{$IFNDEF SmallestBuild}
    { erweiterte Basis methoden, diese methoden nutzen die _helfer }
    function ReadInteger(const FileName, Section, Ident: string; const Default: Integer): Integer; overload;
    function WriteInteger(const FileName, Section, Ident: string; const Value: Integer): Boolean; overload;
    function ReadBoolean(const FileName, Section, Ident: string; const Default: Boolean): Boolean; overload;
    function WriteBoolean(const FileName, Section, Ident: string; const Value: Boolean): Boolean; overload;
    function ReadFloat(const FileName, Section, Ident: string; const Default: Real): Real; overload;
    function WriteFloat(const FileName, Section, Ident: string; const Value: Real): Boolean; overload;
    { methoden für FileName property }
    function ReadString(const Section, Ident, Default: string): string; overload;
    function WriteString(const Section, Ident, Value: string): Boolean; overload;
    function ReadInteger(const Section, Ident: string; const Default: Integer): Integer; overload;
    function WriteInteger(const Section, Ident: string; const Value: Integer): Boolean; overload;
    function ReadBoolean(const Section, Ident: string; const Default: Boolean): Boolean; overload;
    function WriteBoolean(const Section, Ident: string; const Value: Boolean): Boolean; overload;
    function ReadFloat(const Section, Ident: string; const Default: Real): Real; overload;
    function WriteFloat(const Section, Ident: string; const Value: Real): Boolean; overload;
    { methoden für FileName und Section property }
    function ReadString(const Ident, Default: string): string; overload;
    function WriteString(const Ident, Value: string): Boolean; overload;
    function ReadInteger(const Ident: string; const Default: Integer): Integer; overload;
    function WriteInteger(const Ident: string; const Value: Integer): Boolean; overload;
    function ReadBoolean(const Ident: string; const Default: Boolean): Boolean; overload;
    function WriteBoolean(const Ident: string; const Value: Boolean): Boolean; overload;
    function ReadFloat(const Ident: string; const Default: Real): Real; overload;
    function WriteFloat(const Ident: string; const Value: Real): Boolean; overload;
    { methoden für FileName, Section und Ident property }
    function ReadString(const Default: string): string; overload;
    function WriteString(const Value: string): Boolean; overload;
    function ReadInteger(const Default: Integer): Integer; overload;
    function WriteInteger(const Value: Integer): Boolean; overload;
    function ReadBoolean(const Default: Boolean): Boolean; overload;
    function WriteBoolean(const Value: Boolean): Boolean; overload;
    function ReadFloat(const Default: Real): Real; overload;
    function WriteFloat(const Value: Real): Boolean; overload;
  property
    FileName: string read FFileName write FFileName;
  property
    Section: string read FSection write FSection;
  property
    Ident: string read FIdent write FIdent;
{$ENDIF SmallestBuild}
  end;

implementation

uses
  Winapi.Windows;

{$IFNDEF SmallestBuild}

{ Datentypumwandlung Integer nach String }
function TkzIni._IntToStr(const Value: Integer): string;
var
  s: AnsiString;
begin
  Str(Value, s);
  Result := string(s);
end;

{ Datentypumwandlung String nach Integer }
function TkzIni._StrToInt(const Value: string): Integer;
var
  Code: Integer;
begin
  Val(Value, Result, Code);
  if (Code <> 0) then
    Result := 0;
end;

{ Datentypumwandlung Boolean nach String }
function TkzIni._BoolToStr(const Value: Boolean): string;
begin
  Result := _IntToStr(Integer(Value));
end;

{ Datentypumwandlung String nach Boolean }
function TkzIni._StrToBool(const Value: string): Boolean;
begin
  Result := (_StrToInt(Value) <> Integer(False));
end;

{ Datentypumwandlung Float nach String }
function TkzIni._FloatToStr(const Value: Real): string;
var
  s: AnsiString;
begin
  Str(Value, s);
  Result := string(s);
end;

{ Datentypumwandlung String nach Float }
function TkzIni._StrToFloat(const Value: string): Real;
var
  Code: Integer;
begin
  Val(Value, Result, Code);
  if (Code <> 0) then
    Result := 0.0;
end;

{$ENDIF SmallestBuild}

{ Lese String aus Filname Datei }
{ alle leseoperationen führen hier hin }
function TkzIni.ReadString(const FileName, Section, Ident, Default: string): string;
begin
  try
    SetLength(Result, 1024);
    SetLength(Result, GetPrivateProfileString(PChar(Section), PChar(Ident), PChar(Default), PChar(Result), Length(Result) + 1, PChar(FileName)));
  except
    Result := Default;
  end;
end;

{ Schreibe String in Filname Datei }
{ alle schreiboperationen führen hier hin }
function TkzIni.WriteString(const FileName, Section, Ident, Value: string): Boolean;
begin
  try
    Result := WritePrivateProfileString(PChar(Section), PChar(Ident), PChar(Value), PChar(FileName));
  except
    Result := False;
  end;
end;

{$IFNDEF SmallestBuild}

{ Lese Integer aus Filname Datei }
function TkzIni.ReadInteger(const FileName, Section, Ident: string; const Default: Integer): Integer;
begin
  try
    Result := _StrToInt(ReadString(FileName, Section, Ident, _IntToStr(Default)));
  except
    Result := Default;
  end;
end;

{ Schreibe Integer in Filname Datei }
function TkzIni.WriteInteger(const FileName, Section, Ident: string; const Value: Integer): Boolean;
begin
  try
    Result := WriteString(FileName, Section, Ident, _IntToStr(Value));
  except
    Result := False;
  end;
end;

{ Lese Boolean aus Filname Datei }
function TkzIni.ReadBoolean(const FileName, Section, Ident: string; const Default: Boolean): Boolean;
begin
  try
    Result := _StrToBool(ReadString(FileName, Section, Ident, _BoolToStr(Default)));
  except
    Result := Default;
  end;
end;

{ Schreibe Boolean in Filname Datei }
function TkzIni.WriteBoolean(const FileName, Section, Ident: string; const Value: Boolean): Boolean;
begin
  try
    Result := WriteString(FileName, Section, Ident, _BoolToStr(Value));
  except
    Result := False;
  end;
end;

{ Lese Float aus Filname Datei }
function TkzIni.ReadFloat(const FileName, Section, Ident: string; const Default: Real): Real;
begin
  try
    Result := _StrToFloat(ReadString(FileName, Section, Ident, _FloatToStr(Default)));
  except
    Result := Default;
  end;
end;

{ Schreibe Float in Filname Datei }
function TkzIni.WriteFloat(const FileName, Section, Ident: string; const Value: Real): Boolean;
begin
  try
    Result := WriteString(FileName, Section, Ident, _FloatToStr(Value));
  except
    Result := False;
  end;
end;


{ Lese String aus FFilname Datei }
function TkzIni.ReadString(const Section, Ident, Default: string): string;
begin
  try
    Result := ReadString(FFileName, Section, Ident, Default);
  except
    Result := Default;
  end;
end;

{ Schreibe String in FFilname Datei }
function TkzIni.WriteString(const Section, Ident, Value: string): Boolean;
begin
  try
    Result := WriteString(FFileName, Section, Ident, Value);
  except
    Result := False;
  end;
end;

{ Lese Integer aus FFilname Datei }
function TkzIni.ReadInteger(const Section, Ident: string; const Default: Integer): Integer;
begin
  try
    Result := _StrToInt(ReadString(Section, Ident, _IntToStr(Default)));
  except
    Result := Default;
  end;
end;

{ Schreibe Integer in FFilname Datei }
function TkzIni.WriteInteger(const Section, Ident: string; const Value: Integer): Boolean;
begin
  try
    Result := WriteString(Section, Ident, _IntToStr(Value));
  except
    Result := False;
  end;
end;

{ Lese Boolean aus FFilname Datei }
function TkzIni.ReadBoolean(const Section, Ident: string; const Default: Boolean): Boolean;
begin
  try
    Result := _StrToBool(ReadString(Section, Ident, _BoolToStr(Default)));
  except
    Result := Default;
  end;
end;

{ Schreibe Boolean in FFilname Datei }
function TkzIni.WriteBoolean(const Section, Ident: string; const Value: Boolean): Boolean;
begin
  try
    Result := WriteString(Section, Ident, _BoolToStr(Value));
  except
    Result := False;
  end;
end;

{ Lese Float aus FFilname Datei }
function TkzIni.ReadFloat(const Section, Ident: string; const Default: Real): Real;
begin
  try
    Result := _StrToFloat(ReadString(Section, Ident, _FloatToStr(Default)));
  except
    Result := Default;
  end;
end;

{ Schreibe Float in FFilname Datei }
function TkzIni.WriteFloat(const Section, Ident: string; const Value: Real): Boolean;
begin
  try
    Result := WriteString(Section, Ident, _FloatToStr(Value));
  except
    Result := False;
  end;
end;

{ Lese String aus FFilname Datei }
function TkzIni.ReadString(const Ident, Default: string): string;
begin
  try
    Result := ReadString(FFileName, FSection, Ident, Default);
  except
    Result := Default;
  end;
end;

{ Schreibe String in FFilname Datei }
function TkzIni.WriteString(const Ident, Value: string): Boolean;
begin
  try
    Result := WriteString(FFileName, FSection, Ident, Value);
  except
    Result := False;
  end;
end;

{ Lese Integer aus FFilname Datei }
function TkzIni.ReadInteger(const Ident: string; const Default: Integer): Integer;
begin
  try
    Result := _StrToInt(ReadString(Ident, _IntToStr(Default)));
  except
    Result := Default;
  end;
end;

{ Schreibe Integer in FFilname Datei }
function TkzIni.WriteInteger(const Ident: string; const Value: Integer): Boolean;
begin
  try
    Result := WriteString(Ident, _IntToStr(Value));
  except
    Result := False;
  end;
end;

{ Lese Boolean aus FFilname Datei }
function TkzIni.ReadBoolean(const Ident: string; const Default: Boolean): Boolean;
begin
  try
    Result := _StrToBool(ReadString(Ident, _BoolToStr(Default)));
  except
    Result := Default;
  end;
end;

{ Schreibe Boolean in FFilname Datei }
function TkzIni.WriteBoolean(const Ident: string; const Value: Boolean): Boolean;
begin
  try
    Result := WriteString(Ident, _BoolToStr(Value));
  except
    Result := False;
  end;
end;

{ Lese Float aus FFilname Datei }
function TkzIni.ReadFloat(const Ident: string; const Default: Real): Real;
begin
  try
    Result := _StrToFloat(ReadString(Ident, _FloatToStr(Default)));
  except
    Result := Default;
  end;
end;

{ Schreibe Float in FFilname Datei }
function TkzIni.WriteFloat(const Ident: string; const Value: Real): Boolean;
begin
  try
    Result := WriteString(Ident, _FloatToStr(Value));
  except
    Result := False;
  end;
end;

{ Lese String aus FFilname Datei }
function TkzIni.ReadString(const Default: string): string;
begin
  try
    Result := ReadString(FFileName, FSection, FIdent, Default);
  except
    Result := Default;
  end;
end;

{ Schreibe String in FFilname Datei }
function TkzIni.WriteString(const Value: string): Boolean;
begin
  try
    Result := WriteString(FFileName, FSection, FIdent, Value);
  except
    Result := False;
  end;
end;

{ Lese Integer aus FFilname Datei }
function TkzIni.ReadInteger(const Default: Integer): Integer;
begin
  try
    Result := _StrToInt(ReadString(_IntToStr(Default)));
  except
    Result := Default;
  end;
end;

{ Schreibe Integer in FFilname Datei }
function TkzIni.WriteInteger(const Value: Integer): Boolean;
begin
  try
    Result := WriteString(_IntToStr(Value));
  except
    Result := False;
  end;
end;

{ Lese Boolean aus FFilname Datei }
function TkzIni.ReadBoolean(const Default: Boolean): Boolean;
begin
  try
    Result := _StrToBool(ReadString(_BoolToStr(Default)));
  except
    Result := Default;
  end;
end;

{ Schreibe Boolean in FFilname Datei }
function TkzIni.WriteBoolean(const Value: Boolean): Boolean;
begin
  try
    Result := WriteString(_BoolToStr(Value));
  except
    Result := False;
  end;
end;

{ Lese Float aus FFilname Datei }
function TkzIni.ReadFloat(const Default: Real): Real;
begin
  try
    Result := _StrToFloat(ReadString(_FloatToStr(Default)));
  except
    Result := Default;
  end;
end;

{ Schreibe Float in FFilname Datei }
function TkzIni.WriteFloat(const Value: Real): Boolean;
begin
  try
    Result := WriteString(_FloatToStr(Value));
  except
    Result := False;
  end;
end;

{$ENDIF SmallestBuild}

end.

Anregungen, Kritik, Verbesserungen, alles willkommen, tobt Euch aus und viel Spass

[TiGü]

Ich habe nie verstanden, warum jemand bei NonVCL-Projekte (man beachte das Visual Component Library in der Abkürzung) auf Basisfunktionalität aus der RTL (Runtime Library) verzichten sollte.
Oder anderes gefragt: Wenn ich sowas haben wollen würde, warum kopiere ich mir dann nicht einfach die TCustomIniFile und TIniFile aus der Unit System.IniFiles und bin fertig?

[DeddyH]

Ähnliche Gedanken gingen mir auch durch den Kopf.

[KodeZwerg]

Klingt doof, ist aber so, um Dateigröße zu sparen.

[venice2]

Zitat:

Ich habe nie verstanden, warum jemand bei NonVCL-Projekte (man beachte das Visual Component Library in der Abkürzung) auf Basisfunktionalität aus der RTL (Runtime Library) verzichten sollte.

Weil nicht jeder vorgekauten Kram verwenden möchte und über die Hintergründe der Funktionen usw. lernen möchte.
Es gibt viele Bücher die kann man alle lesen solange einem die Zeit dafür bleibt ein eigenes zu schreiben hingegen bedarf Recherche, Hintergrundwissen, Informationen Grammatik natürlich.
Diese bekommt man aber nicht vorgekaut sondern muss es sich erarbeiten.

Der ganze sinn der Verwendung von NonVcl ist das erlernen des Hintergrundwissen.
Irgendwas auf die Form klatschen kann jeder dafür benötigt man auch kein fundiertes wissen.
Und was ist daran falsch mit Bit und Bytes sparsam umzugehen schließlich tut ihr es auch mit eurer Kohle.
Verschwenderische Gesellschaft.

Lass den Mann doch machen wenn er Spaß daran hat.

[DeddyH]

Und Dein ganzes Windows-API-Hintergrundwissen kannst Du in die Tonne treten, wenn Du Dich dann an FMX heranwagst.

[KodeZwerg]

Ok, Projekt in Tonne.

Daniel bitte lösch das alles hier.

[Daniel]

Als Forschungsprojekt bestimmt spannend - man muss sich nur im Klaren sein, das Rad komplett neu zu erfinden. Angefangen von Hilfsfunktionen wie FileExists() bis eben hin zu der INI-Funktionalität. Für Forschungszwecke kann man Tests ggf. vernachlässigen, für den produktiven Einsatz wird es dann vielleicht doch spannend, ob das selbst geschriebene FileExists auch auf Netzwerkpfaden funktioniert und derlei mehr.
Bytes zu sparen ist schön und gut - im gewerblichen Einsatz muss man den Aufwand gegenrechnen und die Frage beantworten, ob es wirklich nötig war, das alles selbst zu schreiben.

[venice2]

Zitat von DeddyH:

Und Dein ganzes Windows-API-Hintergrundwissen kannst Du in die Tonne treten, wenn Du Dich dann an FMX heranwagst.

Wer bracht schon so einen unausgereiften Mist.
FMX ist für die Tone und ein speziell für Delphi entwickeltest Modding Dings.
Wer braucht so was.

Du? Viel Spaß damit.
NB. Es gibt nichts unter FMX das ich mit OpenGL, Unity und konsorte nicht auch erreichen könnte.
Aber es ging hier auch nicht um FMX schlechter vergleich.

Ich arbeite bzw. Beschäftige mich mit Windows nicht mit Android, Smartphones und der gleichen.

Zitat:

man muss sich nur im Klaren sein, das Rad komplett neu zu erfinden.

Habe noch nichts neu erfunden was nicht schon da war.

[himitsu]

[EDIT] Ohh, wo kommen denn die ganzen Antworten her ... dschudlsche, dass NonVCL nochmal erwähnt wird.[/EDIT]

NonVCL bedeutet aber nicht unbedingt NonRTL.

OK, wenn es wirklich nur die Windows-Unit nutzen soll, dann kann man auch direkt auf WinAPI aufbauen (auch das LowerCase ist da vorhanden)
aber gerade auf die grundlegensten und im Normalfall extrem häufig verwendeten Units der RTL zu verzichten .... hmmmm.
Werden die dann doch eigentlich immer irgendwo benutzt, dann ist es den Aufwand eigentlich nicht Wert.
Vor allem auf die SysUtils möchte ich niemals verzichten, oder bastelst du dir eine Exception-Behandlung selbst?


Warum gibt ReadInteger einen Cardinal zurück?

Wozu der Default '' im CreateFile, wenn FileName unbedingt nötig ist?
Auch bei Section und Ident muß man was angeben, sonst isses ja sinnlos.
[edit] außer beim ReadString ... mit etwas Anpassung bekommt man bei leerem Section/Ident (nil) die Liste der Sections zurück.

Den Sinn von _LowerCase hab ich nicht verstanden, da eh nur für für Boolean genutzt wird.
SameText oder CompareString(LOCALE_USER_DEFAULT, NORM_IGNORECASE, ...)

_FileExists ist auch unnötig, da GetPrivateProfileString das bereits beachtet ... erspart auch die doppelte Behandlung des Default.

Und da nun nichts mehr übrig ist ... weg mit dem Objekt

Delphi-Quellcode:

type
  TkzIni = record  // hier gibt es nicht freizugeben ... keine Handles, nur ein gemagagter Typ, also kann man hier die Automatik nutzen
  private
    FFileName: string;
  public
    class function Create(const FileName: string): TkzIni; static;
    function ReadString  (const Section, Ident: string; const Default: string = ''): string;
    function WriteString (const Section, Ident: string; const Value: string = ''): Boolean;
    function ReadInteger (const Section, Ident: string; const Default: Integer = 0): Cardinal;  // wenn man schon überall leer '' als Default nimmt ... dann hier auch, oder nicht?
    function WriteInteger(const Section, Ident: string; const Value: Integer = 0): Boolean;
    function ReadBoolean (const Section, Ident: string; const Default: Boolean = False): Boolean;
    function WriteBoolean(const Section, Ident: string; const Value: Boolean = False): Boolean;
  end;

Beim Write kann man sich überlegen das über eine Exeption regeln zu lassen.
Ich kenne fast niemanden, der bei sowas die Rückgabewerte prüft, also dan besser automatisch prüfen lassen.
Ungültige Pfade und fehlende Schreibrechte sind ja keine unwichtige Sache. Randvoller, Datenträger auch nicht, aber das sollte kaum noch vorkommen. (und wenn doch, dann hat man größere Probleme)

Am Ende ist es sowieso inkonsistent, denn wenn man beim Lesen keine Fehler prüft, kann man es beim Schreiben auch weglassen. (oder andersrum)

Delphi-Quellcode:

function TkzIni.ReadString(const Section, Ident, Default: string): string;
const
  MaxLength: Cardinal = 1024;
begin
  SetLength(Result, MaxLength);
  SetLength(Result, GetPrivateProfileString(PChar(Section), PChar(Ident), PChar(Default), PChar(Result), MaxLength + 1, PChar(FFileName));  // +1 für abschließende #0
end;

function TkzIni.ReadString(const Section, Ident, Default: string): string;
begin
  SetLength(Result, 1024);
  SetLength(Result, GetPrivateProfileString(PChar(Section), PChar(Ident), PChar(Default), PChar(Result), Length(Result) + 1, PChar(FFileName)); // +1 für abschließende #0
end;

PS: Und sooooooooooo groß ist es nicht (da sind andere Dinge schlimmer)
TIniFile ist auch WinAPI, aber auf anderen Plattformen wird es transparent durch TMemIniFile ersetzt.