Serialize / Stream (Read/Write) Configuration Settings

Serialize / Stream (Read/Write) Configuration Settings
Store Application Settings in a Delphi Class and Serialize it Binary to a File
Code submitted by Jens Borrisholt. Text by Zarko Gajic.

 

Learn how to save published properties of a class into a stream / file (binary serialization) and read back. Use it to store application specific configuration data.

 

While using INI files to store application specific configuration data is a piece of cake in Delphi, INI files are simple text files - and everyone could mess up the information inside using a simple Notepad.

 

Have a Custom Object for application configuration

 

Your (simple) application can have a custom class "TSettings" exposing properties and methods to help you manage your application on a more OOP level.

The properties of the Settings class could hold information like form position, location of the database, most recently used resources or anything else that is required for your application to work..

 

Serializing / Streaming a Class

The "SettingsU" unit holds a custom TSettings class exposing 3 properties: PropertyInt (integer value), PropertyString (string value) and PropertyDate (tdatetime value).
The TCustomSettings as a base class defines 4 streaming / serializing methods to save the object and load the object from / to a stream or a file.

SaveToStream and LoadFromStream uses Delphi's RTTI along with the TReader and TWiter class to save any published properties of the TCustomSettings descendant.

 

unit SettingsU;

interface

uses Classes;
{$M+}

type
  TCustomSettings = class
  public
    procedure LoadFromStream(const Stream: TStream) ;
    procedure LoadFromFile(const FileName: string) ;
    procedure SaveToStream(const Stream: TStream) ;
    procedure SaveToFile(const FileName: string) ;
  end;

 

  TSettings = class(TCustomSettings)
  private
    FPropertyString: string;
    FPropertyDate: TDateTime;
    FPropertyInt: Integer;
  published
    property PropertyInt: Integer read FPropertyInt write FPropertyInt;
    property PropertyString: string read FPropertyString write FPropertyString;
    property PropertyDate: TDateTime read FPropertyDate write FPropertyDate;
  end;

 

var
  Settings: TSettings;

 

implementation

uses TypInfo, Sysutils;

 

{ TSettings }

 

procedure TCustomSettings.LoadFromFile(const FileName: string) ;
var
  Stream: TStream;
begin
  Stream := TFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite) ;
  try
    LoadFromStream(Stream) ;
  finally
    Stream.Free;
  end;
end;

 

procedure TCustomSettings.LoadFromStream(const Stream: TStream) ;
var
  Reader: TReader;
  PropName, PropValue: string;
begin
  Reader := TReader.Create(Stream, $FFF) ;
  Stream.Position := 0;
  Reader.ReadListBegin;

  while not Reader.EndOfList do
  begin
    PropName := Reader.ReadString;
    PropValue := Reader.ReadString;
    SetPropValue(Self, PropName, PropValue) ;
  end;

  FreeAndNil(Reader) ;
end;

 

procedure TCustomSettings.SaveToFile(const FileName: string) ;
var
  Stream: TStream;
begin
  Stream := TFileStream.Create(FileName, fmCreate) ;
  try
    SaveToStream(Stream) ;
  finally
    Stream.Free;
  end;
end;

 

procedure TCustomSettings.SaveToStream(const Stream: TStream) ;
var
  PropName, PropValue: string;
  cnt: Integer;
  lPropInfo: PPropInfo;
  lPropCount: Integer;
  lPropList: PPropList;
  lPropType: PPTypeInfo;
  Writer: TWriter;
begin
  lPropCount := GetPropList(PTypeInfo(ClassInfo), lPropList) ;
  Writer := TWriter.Create(Stream, $FFF) ;
  Stream.Size := 0;
  Writer.WriteListBegin;
  for cnt := 0 to lPropCount - 1 do
  begin
    lPropInfo := lPropList^[cnt];
    lPropType := lPropInfo^.PropType;
    if lPropType^.Kind = tkMethod then Continue;

    PropName := lPropInfo.Name;
    PropValue := GetPropValue(Self, lPropInfo) ;
    Writer.WriteString(PropName) ;
    Writer.WriteString(PropValue) ;
  end;

  Writer.WriteListEnd;
  FreeAndNil(Writer) ;
end;

 

initialization
  Settings := TSettings.Create;
finalization
  FreeAndNil(Settings) ;
end.

 

 

Using the TSettings class is easy:

uses SettingsU;
...
begin
  Settings.PropertyInt := 1;
  Settings.PropertyString := 'String';
  Settings.PropertyDate := Now;

  ShowMessage('Settings.Property2 : ' + Settings.PropertyString) ;

  //save the object
  Settings.SaveToFile('Settings.dmp') ;

  Settings.PropertyInt := 2;
  Settings.PropertyString := 'String2';
  Settings.PropertyDate := Now + 200;

  ShowMessage('Settings.Property2 : ' + Settings.PropertyString) ;

  //now load saved state
  Settings.LoadFromFile('Settings.dmp') ;

  ShowMessage('Settings.Property2 : ' + Settings.PropertyString) ;
end;

 

Note: the sample code above uses "Settings.dmp" - but you can name the file whatever you want and give it any extension you like (just make sure not use use registered/well known extensions (like pdf, doc, xml or similar). You can use, for example, "MyApp.settings".

Therefore you only have to call two methods: SaveToFile to save your configuration class and LoadFromFile to load the configuration back when needed (application startup).

 

Note that, in order to use your Settings, you need to derive your class from the provided TSettings - and make sure that you place all the properties you want to stream in the published section - only published properties will be searialized.