1. Computing

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..

Here's how to store user and application data in the "correct location"

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;
 uses Classes;
   TCustomSettings = class
     procedure LoadFromStream(const Stream: TStream) ;
     procedure LoadFromFile(const FileName: string) ;
     procedure SaveToStream(const Stream: TStream) ;
     procedure SaveToFile(const FileName: string) ;
   TSettings = class(TCustomSettings)
     FPropertyString: string;
     FPropertyDate: TDateTime;
     FPropertyInt: Integer;
     property PropertyInt: Integer read FPropertyInt write FPropertyInt;
     property PropertyString: string read FPropertyString write FPropertyString;
     property PropertyDate: TDateTime read FPropertyDate write FPropertyDate;
   Settings: TSettings;
 uses TypInfo, Sysutils;
 { TSettings }
 procedure TCustomSettings.LoadFromFile(const FileName: string) ;
   Stream: TStream;
   Stream := TFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite) ;
     LoadFromStream(Stream) ;
 procedure TCustomSettings.LoadFromStream(const Stream: TStream) ;
   Reader: TReader;
   PropName, PropValue: string;
   Reader := TReader.Create(Stream, $FFF) ;
   Stream.Position := 0;
   while not Reader.EndOfList do
     PropName := Reader.ReadString;
     PropValue := Reader.ReadString;
     SetPropValue(Self, PropName, PropValue) ;
   FreeAndNil(Reader) ;
 procedure TCustomSettings.SaveToFile(const FileName: string) ;
   Stream: TStream;
   Stream := TFileStream.Create(FileName, fmCreate) ;
     SaveToStream(Stream) ;
 procedure TCustomSettings.SaveToStream(const Stream: TStream) ;
   PropName, PropValue: string;
   cnt: Integer;
   lPropInfo: PPropInfo;
   lPropCount: Integer;
   lPropList: PPropList;
   lPropType: PPTypeInfo;
   Writer: TWriter;
   lPropCount := GetPropList(PTypeInfo(ClassInfo), lPropList) ;
   Writer := TWriter.Create(Stream, $FFF) ;
   Stream.Size := 0;
   for cnt := 0 to lPropCount - 1 do
     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) ;
   FreeAndNil(Writer) ;
   Settings := TSettings.Create;
   FreeAndNil(Settings) ;
Using the TSettings class is easy:
 uses SettingsU;
   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) ;
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.

©2014 About.com. All rights reserved.