Hallo,

in einem Programm (nur ein Programmstarter ohne GUI) von mir verwende ich die Unit IniFiles. Unter Delphi 2007 hatte das Kompilat mit dieser Unit eine Größe von 107kB. Dasselbe Programm unter Delphi XE ohne Änderung meines Sourcecodes hat eine Größe von 332kB.

Ok, also habe ich mir mal den Sourcecode von IniFiles (aus Delphi XE) angesehen und mir die 3 benötigten Funktionen daraus kopiert und so umgeschrieben das diese auch ohne Verwendung einer Klasse funktionieren.

Jetzt ist das Programm unter Delphi 2007 erstellt nur noch 53,5kB groß. Wird unter Delphi XE kompiliert erhalte ich eine Dateigröße von 91,5kB.

Mir ist schon klar das die unter Delphi XE kompilierten Programme standardmäßig größer geworden sind, aber das nur die Verwendung der Unit IniFiles das Programm um 225kB aufbläht finde ich recht viel.

Kennt jemand eine Alternative zur standardmäßig mitgelieferten Unit IniFiles? Die Unit FastIniFiles habe ich schon probiert, da ist die Dateigröße des Programmes unter Verwendung von Delphi XE 320KB groß.

Die unit Inifiles ist eigentlich sehr sehr klein, aber sie bindet auch noch die sehr großen Units SysUtils und Classes mit ein, was viel ausmacht, wenn man sie nicht schon im Programm hat

Tja, entweder auf INI verzichten oder sich direkt an die entsprechende WinAPI wenden.
WritePrivateProfileString

Ganz Perverse könnten jetzt auf eine TStringList ausweichen und alles selber parsen, aber ratet mal wo die TStringList herkommt?
AssignFile, ReadLn und selber parsen ginge aber auch noch.

Also SysUtils habe ich sowieso bei mir im Programm drinne. Dann könnte es ja nur noch die Unit Classes sein die in IniFiles verwendet wird.

Die WinAPI GetPrivateProfileString verwende ich ja jetzt da ich mir ja nur die benötigten Funktionen aus der Unit IniFiles kopiert habe und in diesem Fall nur die Funktion zum Lesen der Ini-Datei benötige.

Man kann eigentlich alles bis auf die Units Windows und Messages raus schmeissen. Den Rest den man noch so
braucht kann man zu grossen Teil aus Luckie's "Sammlung" (beispielsweise die MpuTools.pas) beziehen.
Da Spart man sich Arbeit.

Nutzt man dazu noch Delphi 6 für solche Späße spaart man noch 'n paar Bytes der Exe ein.

Hab's nicht gross getestet, aber...

zusammenfalten · markieren

Delphi-Quellcode:

unit UMiniIni;

interface

uses
  Windows;

type
  TMiniIni = class
  private
    FFilename : String;
    FMaxValueLength : Integer;
  public
    constructor Create(IniFilename : String; MaxValueLength : Integer = 255);

    procedure WriteString(Section, Key, Value : String);
    function ReadString(Section, Key, Default : String) : String;
  end;

implementation

{ TMiniIni }

constructor TMiniIni.Create(IniFilename: String; MaxValueLength : Integer = 255);
begin
  FFilename := IniFilename;

  if (MaxValueLength > 32766) then
    FMaxValueLength := 32766
  else if (MaxValueLength < 255) then
    FMaxValueLength := 255
  else
    FMaxValueLength := MaxValueLength;
end;

function TMiniIni.ReadString(Section, Key, Default: String): String;
var
  pResult : PChar;
begin
  GetMem(pResult, FMaxValueLength);
  GetPrivateProfileString(PChar(Section), PChar(Key), PChar(Default),
                          pResult, FMaxValueLength, PChar(FFileName));
  Result := pResult;
  FreeMem(pResult, FMaxValueLength);
end;

procedure TMiniIni.WriteString(Section, Key, Value: String);
var
  OutString : String;
begin
  OutString := Copy(Value, 1, FMaxValueLength);
  WritePrivateProfileString(PChar(Section), PChar(Key),
                            PChar(OutString), PChar(FFilename));
end;

end.

...ich poste es trotzdem.

Wenn man Read/WritePrivateProfileString selbst importiert, spart man sich auch noch uses Windows.

Die Unit Windows erzeugt fast keinen Overhead.

Sieh hat fast nichst / nichts Schlimmes/Großes in Initialization und Finalization stehen und sie bindet auch keine anderen großen Units ein, abgesehn von der Unit Types, welche aber noch kleiner ist.
Da kann man sich also die eigenen Deklarationen ganz getrost ersparen.

Wenn man schon anfängt auf Windows und Co. zu Verzichten, dann sollte man sowieso ganz auf jegliche Units verzichten und mit einer modifizierten System und SysInit arbeiten, dann kommt man selbst mit XE bestimmt noch auf unter 30 KB.
Dann noch auf Objekte verzichtet und alles rein Prozedual gelöst und schon wird die RTTI auch noch kleiner.

OK, hatte da nicht groß nachgeschaut.

War sowieso ein Schnellschuß kurz vor Feierabend

Größenbeschränkung beim Schreiben auch gleich noch vergessen (mal ganz "bequem" schnell eingebaut)

Ich hatte vorher D6 im Einsatz und jetzt mit DXE auch einen enormen Anwuchs der EXE-Dateien festgestellt.

Hallo,

das liegt auch am erweiterten RTTI.
Das kann man auch ausknippsen.

Etwa so wie hier

http://docwiki.embarcadero.com/RADSt...e_%28Delphi%29

Übrigens werden neue Windows7-Dingens unterstützt.
Wer glaubt, dass das ohne zusätzlichen Code geht ???


Heiko

Zitat von hoika:

Wer glaubt, dass das ohne zusätzlichen Code geht ???

Deswegen habe ich ja das hier geschrieben:

Zitat von ringli:

Mir ist schon klar das die unter Delphi XE kompilierten Programme standardmäßig größer geworden sind, ...

Aber der Tip mit der WEAKLINKRTTI-Compilerdirektive war gut. Ich habe das mal bei 2 anderen Programmen probiert und prompt waren die Dateien um ~70kB kleiner.