1. Computing

Serialize / Stream (Read/Write) Configuration Settings

Store Application Settings in a Delphi Class and Serialize it Binary to a File

By

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

©2014 About.com. All rights reserved.