"Поток сознания" о тестировании и программировании: Про "сериализацию" и "архитектуру"

среда, 16 июля 2014 г.

Про "сериализацию" и "архитектуру"

Пусть нам надо уметь сохранять/восстанавливать состояние объекта в поток.

Можно сделать так:

type
 TMyClass = class
  private
   f_Integer : Integer;
   f_Date : TDateTime;
   f_Cardinal : Cardinal;
  public
   procedure SaveTo(aStream: TStream);
   procedure LoadFrom(aStream: TStream);
 end;//TMyClass

procedure TMyClass.SaveTo(aStream: TStream);
begin
 aStream.Write(f_Integer, SizeOf(f_Integer);
 aStream.Write(f_Date, SizeOf(f_Date);
 aStream.Write(f_Cardinal, SizeOf(f_Cardinal);
end;

procedure TMyClass.LoadFrom(aStream: TStream);
begin
 aStream.Read(f_Integer, SizeOf(f_Integer);
 aStream.Read(f_Date, SizeOf(f_Date);
 aStream.Read(f_Cardinal, SizeOf(f_Cardinal);
end;

Но лучше так:

type
 TMyClass = class
  private
   f_Integer : Integer;
   f_Date : TDateTime;
   f_Cardinal : Cardinal;
  public
   procedure SaveTo(aStream: TStream);
   procedure LoadFrom(aStream: TStream);
 end;//TMyClass

procedure TMyClass.SaveTo(aStream: TStream);
begin
 aStream.WriteBuffer(f_Integer, SizeOf(f_Integer);
 aStream.WriteBuffer(f_Date, SizeOf(f_Date);
 aStream.WriteBuffer(f_Cardinal, SizeOf(f_Cardinal);
end;

procedure TMyClass.LoadFrom(aStream: TStream);
begin
 aStream.ReadBuffer(f_Integer, SizeOf(f_Integer);
 aStream.ReadBuffer(f_Date, SizeOf(f_Date);
 aStream.ReadBuffer(f_Cardinal, SizeOf(f_Cardinal);
end;

А ещё лучше так:

type
 TStreamHelper = class
  private
   f_Stream : TStream;
  public
   constructor Create(aStream: TStream);
 end;//TStreamHelper

 TReader = class(TStreamHelper)
  public
   function ReadInteger;
   function ReadDate;
   function ReadCardinal;
 end;//TReader

 TWriter = class(TStreamHelper)
  public
   procedure WriteInteger(aValue: Integer);
   procedure WriteDate(aValue: TDateTime);
   procedure WriteCardinal(aValue: Cardinal);
 end;//TWriter

 TMyClass = class
  private
   f_Integer : Integer;
   f_Date : TDateTime;
   f_Cardinal : Cardinal;
  public
   procedure SaveTo(aStream: TWriter);
   procedure LoadFrom(aStream: TReader);
 end;//TMyClass

constructor TStreamHelper.Create(aStream: TStream);
begin
 inherited Create;
 f_Stream := aStream;
end;

function TReader.ReadInteger;
begin
 f_Stream.ReadBuffer(Result, SizeOf(Result));
end;

function TReader.ReadDate;
begin
 f_Stream.ReadBuffer(Result, SizeOf(Result));
end;

function TReader.ReadCardinal;
begin
 f_Stream.ReadBuffer(Result, SizeOf(Result));
end;

procedure TWriter.WriteInteger(aValue: Integer);
begin
 f_Stream.WriteBuffer(aValue, SizeOf(aValue));
end;

procedure TWriter.WriteDate(aValue: TDateTime);
begin
 f_Stream.WriteBuffer(aValue, SizeOf(aValue));
end;

procedure TWriter.WriteCardinal(aValue: Cardinal);
begin
 f_Stream.WriteBuffer(aValue, SizeOf(aValue));
end;

procedure TMyClass.SaveTo(aStream: TWriter);
begin
 aStream.WriteInteger(f_Integer);
 aStream.WriteDate(f_Date);
 aStream.WriteCardinal(f_Cardinal);
end;

procedure TMyClass.LoadFrom(aStream: TReader);
begin
 f_Integer := aStream.ReadInteger;
 f_Date := aStream.ReadDate;
 f_Cardinal := aStream.ReadCardinal;
end;

Понятно почему?

Потому что в TReader и TWriter можно убрать "настоящую сериализацию".

Например сделать (грубо) так:

type
 TStreamHelper = class
  private
   f_Stream : TStream;
  public
   constructor Create(aStream: TStream);
 end;//TStreamHelper

 TSignature = (sigInteger, sigDate, sigCardinal);

 TReader = class(TStreamHelper)
  private
   procedure CheckSignature(aSig: TSignature);
  public
   function ReadInteger;
   function ReadDate;
   function ReadCardinal;
   constructor Create(aStream: TStream);
 end;//TReader

 TWriter = class(TStreamHelper)
  private
   procedure WriteSignature(aSig: TSignature);
  public
   procedure WriteInteger(aValue: Integer);
   procedure WriteDate(aValue: TDateTime);
   procedure WriteCardinal(aValue: Cardinal);
   constructor Create(aStream: TStream);
 end;//TWriter

 TMyClass = class
  private
   f_Integer : Integer;
   f_Date : TDateTime;
   f_Cardinal : Cardinal;
  public
   procedure SaveTo(aStream: TWriter);
   procedure LoadFrom(aStream: TReader);
 end;//TMyClass

constructor TStreamHelper.Create(aStream: TStream);
begin
 inherited Create;
 f_Stream := aStream;
end;

procedure TReader.CheckSignature(aSig: TSignature);
var
 l_Sig : TSignature;
begin
 f_Stream.ReadBuffer(l_Sig, SizeOf(l_Sig));
 Assert(l_Sig = aSig);
end;

const
 cVersion = 1;

constructor TReader.Create(aStream: TStream);
begin
 inherited;
 Assert(ReadCardinal = cVersion);
end;

function TReader.ReadInteger;
begin
 CheckSignature(sigInteger);
 f_Stream.ReadBuffer(Result, SizeOf(Result));
end;

function TReader.ReadDate;
begin
 CheckSignature(sigDate);
 f_Stream.ReadBuffer(Result, SizeOf(Result));
end;

function TReader.ReadCardinal;
begin
 CheckSignature(sigCardinal);
 f_Stream.ReadBuffer(Result, SizeOf(Result));
end;

constructor TWriter.Create(aStream: TStream);
begin
 inherited;
 WriteCardinal(cVersion);
end;

procedure TWriter.WriteSignature(aSig: TSignature);
begin
 f_Stream.WriteBuffer(aSig, SizeOf(aSig));
end;

procedure TWriter.WriteInteger(aValue: Integer);
begin
 WriteSignature(sigInteger);
 f_Stream.WriteBuffer(aValue, SizeOf(aValue));
end;

procedure TWriter.WriteDate(aValue: TDateTime);
begin
 WriteSignature(sigDate);
 f_Stream.WriteBuffer(aValue, SizeOf(aValue));
end;

procedure TWriter.WriteCardinal(aValue: Cardinal);
begin
 WriteSignature(sigCardinal);
 f_Stream.WriteBuffer(aValue, SizeOf(aValue));
end;

procedure TMyClass.SaveTo(aStream: TWriter);
begin
 aStream.WriteInteger(f_Integer);
 aStream.WriteDate(f_Date);
 aStream.WriteCardinal(f_Cardinal);
end;

procedure TMyClass.LoadFrom(aStream: TReader);
begin
 f_Integer := aStream.ReadInteger;
 f_Date := aStream.ReadDate;
 f_Cardinal := aStream.ReadCardinal;
end;

Почему ReadXXX это функция, а не процедура?

А потому, что можно сделать так:

type
 TStreamHelper = class
  private
   f_Stream : TStream;
  public
   constructor Create(aStream: TStream);
 end;//TStreamHelper

 TSignature = (sigInteger, sigDate, sigCardinal);

 TReader = class(TStreamHelper)
  private
   procedure CheckSignature(aSig: TSignature);
  public
   function ReadInteger;
   function ReadDate;
   function ReadCardinal;
 end;//TReader

 TWriter = class(TStreamHelper)
  private
   procedure WriteSignature(aSig: TSignature);
  public
   procedure WriteInteger(aValue: Integer);
   procedure WriteDate(aValue: TDateTime);
   procedure WriteCardinal(aValue: Cardinal);
 end;//TWriter

 TMyClass = class
  private
   f_Integer : Integer;
   f_Date : TDateTime;
   f_Cardinal : Cardinal;
  public
   property IntegerProp: Integer read f_Integer write f_Integer;
   property DateProp: Integer read f_Date write f_Date;
   property CardinalProp: Integer read f_Cardinal write f_Cardinal;
  public
   procedure SaveTo(aStream: TWriter);
   procedure LoadFrom(aStream: TReader);
 end;//TMyClass

constructor TStreamHelper.Create(aStream: TStream);
begin
 inherited Create;
 f_Stream := aStream;
end;

procedure TReader.CheckSignature(aSig: TSignature);
var
 l_Sig : TSignature;
begin
 f_Stream.ReadBuffer(l_Sig, SizeOf(l_Sig));
 Assert(l_Sig = aSig);
end;

function TReader.ReadInteger;
begin
 CheckSignature(sigInteger);
 f_Stream.ReadBuffer(Result, SizeOf(Result));
end;

function TReader.ReadDate;
begin
 CheckSignature(sigDate);
 f_Stream.ReadBuffer(Result, SizeOf(Result));
end;

function TReader.ReadCardinal;
begin
 CheckSignature(sigCardinal);
 f_Stream.ReadBuffer(Result, SizeOf(Result));
end;

procedure TWriter.WriteSignature(aSig: TSignature);
begin
 f_Stream.WriteBuffer(aSig, SizeOf(aSig));
end;

procedure TWriter.WriteInteger(aValue: Integer);
begin
 WriteSignature(sigInteger);
 f_Stream.WriteBuffer(aValue, SizeOf(aValue));
end;

procedure TWriter.WriteDate(aValue: TDateTime);
begin
 WriteSignature(sigDate);
 f_Stream.WriteBuffer(aValue, SizeOf(aValue));
end;

procedure TWriter.WriteCardinal(aValue: Cardinal);
begin
 WriteSignature(sigCardinal);
 f_Stream.WriteBuffer(aValue, SizeOf(aValue));
end;

procedure TMyClass.SaveTo(aStream: TWriter);
begin
 aStream.WriteInteger(f_Integer);
 aStream.WriteDate(f_Date);
 aStream.WriteCardinal(f_Cardinal);
end;

procedure TMyClass.LoadFrom(aStream: TReader);
begin
 IntegerProp := aStream.ReadInteger;
 DateProp := aStream.ReadDate;
 CardinalProp := aStream.ReadCardinal;
end;

Мысль понятна?

Что-то напоминает?

А что ещё можно сделать?

А можно ВООБЩЕ - НЕ СВЯЗЫВАТЬСЯ с "бинарной сериализацией".

Как?

Позже попробую написать.

А пока почитайте вот что:

http://programmingmindstream.blogspot.ru/2014/04/sax.html
http://programmingmindstream.blogspot.ru/2014/04/blog-post_24.html
http://programmingmindstream.blogspot.ru/2014/04/blog-post_25.html
http://programmingmindstream.blogspot.ru/2014/04/blog-post_104.html

+Igor Belyh Это кстати для вас :-) В продолжение к тому, над чем мы трудимся.

И ещё ссылка - https://developer.apple.com/library/mac/documentation/Cocoa/Reference/Foundation/Classes/NSDictionary_Class/Reference/Reference.html

И ещё:
https://sourceforge.net/p/rumtmarc/code-0/HEAD/tree/trunk/Blogger/RealWork/EVD/evdReader.pas
https://sourceforge.net/p/rumtmarc/code-0/HEAD/tree/trunk/Blogger/RealWork/EVD/evdWriter.pas
https://sourceforge.net/p/rumtmarc/code-0/HEAD/tree/trunk/Blogger/RealWork/K2/k2DocumentBuffer.pas
https://sourceforge.net/p/rumtmarc/code-0/HEAD/tree/trunk/Blogger/RealWork/K2/k2DocumentGenerator.pas

Возвращаясь к "бинарной сериализации" - если всё таки "с ней решили связываться".

Понятно, что "следующий шаг" вот такой?

function TReader.ReadTYPE(const aName: String): TYPE;
begin
 CheckSignature(TYPE);
 Assert(aName = ReadString);
 f_Stream.ReadBuffer(Result, SizeOf(Result);
end;

procedure TWriter.WriteTYPE(const aName: String; aValue: TYPE);
begin
 WriteSignature(TYPE);
 WriteString(aName);
 f_Stream.WriteBuffer(aValue, SizeOf(aValue);
end;

Ну и "вдогонку":
http://programmingmindstream.blogspot.ru/2014/06/blog-post_18.html
http://programmingmindstream.blogspot.ru/2014/06/blog-post_5984.html

Но ПОВТОРЮ, что ОСНОВНАЯ мысль поста в том, что "с бинарной сериализацией" - лучше не связываться.

Лучше оперировать понятием "схемы данных".

И чтение/запись проводить через СХЕМУ, а не "напрямую" из классов.

Ну и ещё:

https://sourceforge.net/p/rumtmarc/code-0/HEAD/tree/trunk/Blogger/RealWork/EVD/evdXMLReader.pas
https://sourceforge.net/p/rumtmarc/code-0/HEAD/tree/trunk/Blogger/RealWork/EVD/evdCustomXMLReader.pas
https://sourceforge.net/p/rumtmarc/code-0/HEAD/tree/trunk/Blogger/RealWork/EVD/evdXMLWriter.pas
https://sourceforge.net/p/rumtmarc/code-0/HEAD/tree/trunk/Blogger/RealWork/L3/l3XMLWriter.pas

Почему "не связываться с бинарной сериализацией"?

А потому, что "персистентные хранилища" - они ОЧЕНЬ ПЛОХО к ней относятся. Даже "запись номера версии" - НЕ ПОМОГАЕТ.

У меня когда-то была "бинарная сериализация". В "середине девяностых".

Потом я её заменил на "схему". С поддержкой "бинарной сериализации".

Потом я эту поддержку ГРОХНУЛ. Не так давно. Думая - "ну наверное таких документов уже и в природе не осталось"...

И что вы думаете?

Мне начали "всплывать документы" из "середины 90-х"... И Пользователи начали жаловаться....

Такая вот "долгая память" у "бинарной сериализации"...

37 комментариев:

NameRec17 июля 2014 г. в 09:21
Зачем для сериализации нужна какая-то непонятная "схема данных"?
Для решения задачи сохранения состояния объекта эта "схема данных" есть "из коробки" - структура объекта, доступная через RTTI. Ну плюс один-два виртуальных метода для отражения специфики, не укладывающейся в общую схему.
Или Вы не о сериализации, а о маршаллинге говорите?
Тогда понятно: если "на том конце" может быть не Delphi, то какая-то схема, описывающая интерфейс взаимодействия (сигнатуры методов, например, или передаваемые структуры) может пригодится.
ОтветитьУдалить
Ответы

Добавить комментарий

среда, 16 июля 2014 г.

Про "сериализацию" и "архитектуру"

37 комментариев:

среда, 16 июля 2014 г.