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.

[Delphi-Laie]

Zitat von TiGü:

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?

Weil es - bei Veröffentlichung - mit dem Urheberrecht kollidiert?!