Difference between revisions of "Streaming components/de"

From Free Pascal wiki
Jump to navigationJump to search
 
(5 intermediate revisions by 2 users not shown)
Line 1: Line 1:
 
{{Streaming components}}
 
{{Streaming components}}
 
+
<br>
 +
Zurück zu den [[Additional information/de|Zusätzlichen Informationen]].<br>
 +
<br>
 +
__TOC__
 +
<br>
 
== Einleitung ==
 
== Einleitung ==
  
Line 13: Line 17:
 
== TComponent / TPersistent ==
 
== TComponent / TPersistent ==
  
Die Klasse '''TPersistent''' ist definiert in der Unit Classes und verwendet den '''{$M+}''' Compilerschalter. Dieser Schalter veranlasst den Compiler, Laufzeit Typinformationen (engl. Run Time Type Information) ('''RTTI''') zu erzeugen. Das bedeutet, sie und alle ihre Nachfahren erhalten einen neuen Klassenabschnitt '''published'''. 'Published' Eigenschaften sind sichtbar wie 'public', aber zusätzlich ist ihre Struktur zur (?Laufzeit?) Designtime erreichbar. Das bedeutet, alle published Eigenschaften können zur (?Laufzeit?) Designtime gelesen und geschrieben werden. Die IDE zum Beispiel verwendet dies, um mit Komponenten zu arbeiten, die sie nicht kennt.
+
Die Klasse '''TPersistent''' ist definiert in der Unit Classes und verwendet den Compilerschalter '''{$M+}'''. Dieser Schalter veranlasst den Compiler, Laufzeit-Typinformationen (engl. Run Time Type Information, '''RTTI''') zu erzeugen.
 +
Das bedeutet, die Klasse und alle ihre Nachfahren erhalten einen neuen Klassenabschnitt '''published'''. 'Published'-Eigenschaften sind sichtbar wie 'public', aber zusätzlich ist ihre Struktur zur Laufzeit erreichbar. Alle published-Eigenschaften können zur Laufzeit gelesen und geschrieben werden, ohne dass ihr Name bekannt sein muss, während das Programm geschrieben wird. Lazarus kann damit alle Komponenten verwenden, ohne dass für jede Komponente neuer Code geschrieben werden muss.
  
 
'''TComponent''' erweitert TPersistent durch die Möglichkeit, child components zu haben. Das ist wichtig für das streaming, wo eine Komponente die '''root component''' auch '''lookup root''' genannt ist mit einer Liste (list) von Child-Komponenten.
 
'''TComponent''' erweitert TPersistent durch die Möglichkeit, child components zu haben. Das ist wichtig für das streaming, wo eine Komponente die '''root component''' auch '''lookup root''' genannt ist mit einer Liste (list) von Child-Komponenten.
Line 27: Line 32:
  
 
Eine maßgeschneiderte Komponente kann so einfach sein wie:
 
Eine maßgeschneiderte Komponente kann so einfach sein wie:
+
<syntaxhighlight lang="delphi">
type
+
type
 
   TMyComponent = class(TComponent)
 
   TMyComponent = class(TComponent)
 
   private
 
   private
Line 35: Line 40:
 
     property ID: integer read FID write FID;
 
     property ID: integer read FID write FID;
 
   end;
 
   end;
 
+
</syntaxhighlight>
 
== Schreiben einer Komponente in einen Stream ==
 
== Schreiben einer Komponente in einen Stream ==
  
 
Die Unit [[doc:lcl/lresources|LResources]] hat eine Funktion dafür:  
 
Die Unit [[doc:lcl/lresources|LResources]] hat eine Funktion dafür:  
  procedure WriteComponentAsBinaryToStream(AStream: TStream; AComponent: TComponent);
+
<syntaxhighlight lang="delphi">
 +
procedure WriteComponentAsBinaryToStream(AStream: TStream; AComponent: TComponent);
 +
</syntaxhighlight>
  
 
Sie schreibt eine Komponente im binären Format in den Stream.
 
Sie schreibt eine Komponente im binären Format in den Stream.
 
Zum Beispiel:
 
Zum Beispiel:
<pre>
+
<syntaxhighlight lang="delphi">
 
procedure TForm1.Button1Click(Sender: TObject);
 
procedure TForm1.Button1Click(Sender: TObject);
 
var
 
var
Line 51: Line 58:
 
   try
 
   try
 
     WriteComponentAsBinaryToStream(AStream,AGroupBox);
 
     WriteComponentAsBinaryToStream(AStream,AGroupBox);
     ... save stream somewhere ...
+
     // ... Stream weiterverarbeiten oder abspeichern ...
 
   finally
 
   finally
 
     AStream.Free;
 
     AStream.Free;
 
   end;
 
   end;
 
end;
 
end;
</pre>
+
</syntaxhighlight>
  
 
== Lesen einer Komponente aus einem Stream ==
 
== Lesen einer Komponente aus einem Stream ==
  
 
Die Unit LResources hat eine Funktion dafür:  
 
Die Unit LResources hat eine Funktion dafür:  
  procedure ReadComponentFromBinaryStream(AStream: TStream;
+
<syntaxhighlight lang="delphi">
    var RootComponent: TComponent; OnFindComponentClass: TFindComponentClassEvent; TheOwner: TComponent = nil);
+
procedure ReadComponentFromBinaryStream(AStream: TStream;
 +
  var RootComponent: TComponent; OnFindComponentClass: TFindComponentClassEvent; TheOwner: TComponent = nil);
 +
</syntaxhighlight>
  
 
* AStream ist der Stream, der eine Komponente im binären Format enthält.
 
* AStream ist der Stream, der eine Komponente im binären Format enthält.
 
* RootComponent ist entweder eine existierende Komponente, deren Daten überschrieben werden, oder ist null und eine neue Komponente wird erzeugt.
 
* RootComponent ist entweder eine existierende Komponente, deren Daten überschrieben werden, oder ist null und eine neue Komponente wird erzeugt.
 
* OnFindComponentClass ist eine Funktion, die von TReader verwendet wird, um die Klasse aus den Klassennamen im Stream zu erhalten. Zum Beispiel:
 
* OnFindComponentClass ist eine Funktion, die von TReader verwendet wird, um die Klasse aus den Klassennamen im Stream zu erhalten. Zum Beispiel:
<pre>
+
 
 +
<syntaxhighlight lang="delphi">
 
procedure TCompStreamDemoForm.OnFindClass(Reader: TReader;
 
procedure TCompStreamDemoForm.OnFindClass(Reader: TReader;
 
   const AClassName: string; var ComponentClass: TComponentClass);
 
   const AClassName: string; var ComponentClass: TComponentClass);
Line 76: Line 86:
 
     ComponentClass:=TCheckBox;
 
     ComponentClass:=TCheckBox;
 
end;
 
end;
</pre>
+
</syntaxhighlight>
 +
 
 
* TheOwner is the component owner, when creating a new component.
 
* TheOwner is the component owner, when creating a new component.
  
Line 91: Line 102:
  
 
Sie können zusätzlich beliebige Daten streamen, indem Sie '''DefineProperties''' überschreiben(=override). So können Sie alle Daten streamen, die keine passenden Grund-Typen haben. Beispiel : um eine Variable  '''FMyRect: TRect''' Ihrer Komponente zu überschreiben, fügen sie die folgenden drei Methoden zu ihrer Komponente hinzu:
 
Sie können zusätzlich beliebige Daten streamen, indem Sie '''DefineProperties''' überschreiben(=override). So können Sie alle Daten streamen, die keine passenden Grund-Typen haben. Beispiel : um eine Variable  '''FMyRect: TRect''' Ihrer Komponente zu überschreiben, fügen sie die folgenden drei Methoden zu ihrer Komponente hinzu:
<pre>
+
<syntaxhighlight lang="delphi">
 
procedure DefineProperties(Filer: TFiler); override;
 
procedure DefineProperties(Filer: TFiler); override;
 
procedure ReadMyRect(Reader: TReader);
 
procedure ReadMyRect(Reader: TReader);
 
procedure WriteMyRect(Writer: TWriter);
 
procedure WriteMyRect(Writer: TWriter);
</pre>
+
</syntaxhighlight>
  
 
mit dem folgenden Code:
 
mit dem folgenden Code:
  
<pre>
+
<syntaxhighlight lang="delphi">
 
procedure TMyComponent.DefineProperties(Filer: TFiler);
 
procedure TMyComponent.DefineProperties(Filer: TFiler);
 
var
 
var
Line 135: Line 146:
 
   end;
 
   end;
 
end;
 
end;
</pre>
+
</syntaxhighlight>
  
 
Dies wird MyRect als Eigenschaft 'MyRect' speichern.
 
Dies wird MyRect als Eigenschaft 'MyRect' speichern.
Line 142: Line 153:
  
 
Die Unit LResources enthält ein Beispiel, wie man eine Prozedur schreibt, um eine rect Eigenschaft zu definieren:
 
Die Unit LResources enthält ein Beispiel, wie man eine Prozedur schreibt, um eine rect Eigenschaft zu definieren:
 
+
<syntaxhighlight lang="delphi">
  procedure DefineRectProperty(Filer: TFiler; const Name: string; ARect, DefaultRect: PRect);
+
procedure DefineRectProperty(Filer: TFiler; const Name: string; ARect, DefaultRect: PRect);
 
+
</syntaxhighlight>
 
Auf diese Art kann der obige Code kurz gehalten werden :
 
Auf diese Art kann der obige Code kurz gehalten werden :
<pre>
+
<syntaxhighlight lang="delphi">
 
procedure TMyComponent.DefineProperties(Filer: TFiler);
 
procedure TMyComponent.DefineProperties(Filer: TFiler);
 
begin
 
begin
Line 152: Line 163:
 
   DefineRectProperty(Filer,'MyRect',@FMyRect,nil);
 
   DefineRectProperty(Filer,'MyRect',@FMyRect,nil);
 
end;
 
end;
</pre>
+
</syntaxhighlight>
  
 
== Schreiben ihrer eigenen Komponente - Teil 2 ==
 
== Schreiben ihrer eigenen Komponente - Teil 2 ==
  
 
Jetzt kann das Beispiel erweitert werden und wir können beliebige Eigenschaften verwenden mit nur ein paar Zeilen Code:
 
Jetzt kann das Beispiel erweitert werden und wir können beliebige Eigenschaften verwenden mit nur ein paar Zeilen Code:
<pre>
+
<syntaxhighlight lang="delphi">
 
type
 
type
 
   TMyComponent = class(TComponent)
 
   TMyComponent = class(TComponent)
Line 179: Line 190:
 
   DefineRectProperty(Filer,'Rect2',@FRect2,nil);
 
   DefineRectProperty(Filer,'Rect2',@FRect2,nil);
 
end;
 
end;
</pre>
+
</syntaxhighlight>
  
 
Diese Komponente kann nun gespeichert, geladen oder von den [[RTTI controls/de|RTTI Bedienelementen]] verwendet werden. Sie müssen keinen weiteren Code schreiben.
 
Diese Komponente kann nun gespeichert, geladen oder von den [[RTTI controls/de|RTTI Bedienelementen]] verwendet werden. Sie müssen keinen weiteren Code schreiben.
Line 194: Line 205:
 
== Fazit ==
 
== Fazit ==
  
RTTI ist ein leistungsstarker Mechanismus, der verwendet werden kann, um einfach ganze Klassen zu streamen, und er hilft das Schreiben von langweiligem Laden/Speichern Code zu vermeiden.
+
<abbr title="Run Time Type Information">RTTI</abbr> ist ein leistungsstarker Mechanismus, der verwendet werden kann, um einfach ganze Klassen zu streamen, und er hilft das Schreiben von langweiligem Laden/Speichern Code zu vermeiden.
 +
 
 +
==Siehe auch ==
 +
 
 +
* [[RTTI controls/de|RTTI controls]]
  
Siehe auch
 
  
[[RTTI controls/de|RTTI controls]]
+
[[Category:Tutorials/de]]
 +
[[Category:Components/de]]
 +
{{AutoCategory}}

Latest revision as of 13:13, 7 May 2014

Deutsch (de) English (en) français (fr) 日本語 (ja) polski (pl) português (pt)

Zurück zu den Zusätzlichen Informationen.


Einleitung

Normalerweise, wenn sie die Eigenschaftswerte eines Objekts speichern wollen, müssen sie Code schreiben für das Laden und Speichern jeder Eigenschaft. Dieses Tutorial beschreibt, wie man Klassen entwickelt, die ihre Eigenschaftswerte über einen Stream laden und speichern können ohne zusätzlichen Code dafür schreiben zu müssen. Dies geht unter Verwendung der RTTI.

Es gibt ein Beispiel in den Lazarus Quelltexten, welches demonstriert, wie eine TGroupBox mit einer eingebetteten TCheckBox-Komponente über einen Stream gespeichert wird und durch lesen aus einem Stream neu erzeugt werden kann.

 Siehe <lazaruspath>/examples/componentstreaming/

In Kombination mit RTTI Bedienelementen können sie den Umfang des Codes, der für das Verbinden der Programmdaten mit dem GUI und der Platte / dem Netzwerk benötigt wird, auf ein Minimum reduzieren.

TComponent / TPersistent

Die Klasse TPersistent ist definiert in der Unit Classes und verwendet den Compilerschalter {$M+}. Dieser Schalter veranlasst den Compiler, Laufzeit-Typinformationen (engl. Run Time Type Information, RTTI) zu erzeugen. Das bedeutet, die Klasse und alle ihre Nachfahren erhalten einen neuen Klassenabschnitt published. 'Published'-Eigenschaften sind sichtbar wie 'public', aber zusätzlich ist ihre Struktur zur Laufzeit erreichbar. Alle published-Eigenschaften können zur Laufzeit gelesen und geschrieben werden, ohne dass ihr Name bekannt sein muss, während das Programm geschrieben wird. Lazarus kann damit alle Komponenten verwenden, ohne dass für jede Komponente neuer Code geschrieben werden muss.

TComponent erweitert TPersistent durch die Möglichkeit, child components zu haben. Das ist wichtig für das streaming, wo eine Komponente die root component auch lookup root genannt ist mit einer Liste (list) von Child-Komponenten.

TReader / TWriter

Diese Klassen erledigen die Arbeit und schreiben/lesen ein TComponent in den/aus dem Stream. (siehe: CreateLRSReader und CreateLRSWriter). Sie benutzen einen Driver, um ein spezielles Format zu lesen/schreiben. Momentan gibt es einen reader (TLRSObjectReader) und einen writer (TLRSObjectWriter) für das binary object format in der unit LResources und einen writer (TXMLObjectWriter) für TDOMDocument in der unit Laz_XMLStreaming. Die LResources Unit enthält auch Funktionen, um das binäre Format in Text zu konvertieren und umgekehrt (LRSObjectBinaryToText, LRSObjectTextToBinary). Die LCL bevorzugt UTF8 für Strings, während Delphi Widestrings bevorzugt. Daher gibt es auch einige Konvertierungsfunktionen.

Schreiben ihrer eigenen Komponente - Teil 1

Eine maßgeschneiderte Komponente kann so einfach sein wie:

 
type
  TMyComponent = class(TComponent)
  private
    FID: integer;
  published
    property ID: integer read FID write FID;
  end;

Schreiben einer Komponente in einen Stream

Die Unit LResources hat eine Funktion dafür:

procedure WriteComponentAsBinaryToStream(AStream: TStream; AComponent: TComponent);

Sie schreibt eine Komponente im binären Format in den Stream. Zum Beispiel:

procedure TForm1.Button1Click(Sender: TObject);
var
  AStream: TMemoryStream;
begin
  AStream:=TMemoryStream.Create;
  try
    WriteComponentAsBinaryToStream(AStream,AGroupBox);
    // ... Stream weiterverarbeiten oder abspeichern ...
  finally
    AStream.Free;
  end;
end;

Lesen einer Komponente aus einem Stream

Die Unit LResources hat eine Funktion dafür:

procedure ReadComponentFromBinaryStream(AStream: TStream;
  var RootComponent: TComponent; OnFindComponentClass: TFindComponentClassEvent; TheOwner: TComponent = nil);
  • AStream ist der Stream, der eine Komponente im binären Format enthält.
  • RootComponent ist entweder eine existierende Komponente, deren Daten überschrieben werden, oder ist null und eine neue Komponente wird erzeugt.
  • OnFindComponentClass ist eine Funktion, die von TReader verwendet wird, um die Klasse aus den Klassennamen im Stream zu erhalten. Zum Beispiel:
procedure TCompStreamDemoForm.OnFindClass(Reader: TReader;
  const AClassName: string; var ComponentClass: TComponentClass);
begin
  if CompareText(AClassName,'TGroupBox')=0 then
    ComponentClass:=TGroupBox
  else if CompareText(AClassName,'TCheckBox')=0 then
    ComponentClass:=TCheckBox;
end;
  • TheOwner is the component owner, when creating a new component.

Streambare Eigenschaften

Es gibt einige Einschränkungen, welche Typen TReader/TWriter streamen kann:

  • Basistypen können gestreamt werden: string, integer, char, single, double, extended, byte, word, cardinal, shortint, method pointers, etc. .
  • TPersistent und Nachfahren können gestreamt werden
  • Records, Objekte und Klassen, die nicht von TPersistent abstammen, können nicht gestreamt werden. um sie zu streamen muss man TReader/TWriter mitteilen wie. Siehe unten #Streaming custom Data - DefineProperties.

Streaming custom Data - DefineProperties

Sie können zusätzlich beliebige Daten streamen, indem Sie DefineProperties überschreiben(=override). So können Sie alle Daten streamen, die keine passenden Grund-Typen haben. Beispiel : um eine Variable FMyRect: TRect Ihrer Komponente zu überschreiben, fügen sie die folgenden drei Methoden zu ihrer Komponente hinzu:

procedure DefineProperties(Filer: TFiler); override;
procedure ReadMyRect(Reader: TReader);
procedure WriteMyRect(Writer: TWriter);

mit dem folgenden Code:

procedure TMyComponent.DefineProperties(Filer: TFiler);
var
  MyRectMustBeSaved: Boolean;
begin
  inherited DefineProperties(Filer);
  MyRectMustBeSaved:=(MyRect.Left<>0)
                     or (MyRect.Top<>0)
                     or (MyRect.Right<>0)
                     or (MyRect.Bottom<>0);
  Filer.DefineProperty('MyRect',@ReadMyRect,@WriteMyRect,MyRectMustBeSaved);
end;

procedure TMyComponent.ReadMyRect(Reader: TReader);
begin
  with Reader do begin
    ReadListBegin;
    FMyRect.Left:=ReadInteger;
    FMyRect.Top:=ReadInteger;
    FMyRect.Right:=ReadInteger;
    FMyRect.Bottom:=ReadInteger;
    ReadListEnd;
  end;
end;

procedure TMyComponent.WriteMyRect(Writer: TWriter);
begin
  with Writer do begin
    WriteListBegin;
    WriteInteger(FMyRect.Left);
    WriteInteger(FMyRect.Top);
    WriteInteger(FMyRect.Right);
    WriteInteger(FMyRect.Bottom);
    WriteListEnd;
  end;
end;

Dies wird MyRect als Eigenschaft 'MyRect' speichern.

Falls Sie oft TRect streamen , dann wollen sie wahrscheinlich nicht jedes Mal den ganzen Code schreiben.

Die Unit LResources enthält ein Beispiel, wie man eine Prozedur schreibt, um eine rect Eigenschaft zu definieren:

procedure DefineRectProperty(Filer: TFiler; const Name: string; ARect, DefaultRect: PRect);

Auf diese Art kann der obige Code kurz gehalten werden :

procedure TMyComponent.DefineProperties(Filer: TFiler);
begin
  inherited DefineProperties(Filer);
  DefineRectProperty(Filer,'MyRect',@FMyRect,nil);
end;

Schreiben ihrer eigenen Komponente - Teil 2

Jetzt kann das Beispiel erweitert werden und wir können beliebige Eigenschaften verwenden mit nur ein paar Zeilen Code:

type
  TMyComponent = class(TComponent)
  private
    FID: integer;
    FRect1: TRect;
    FRect2: TRect;
  protected
    procedure DefineProperties(Filer: TFiler); override;
  public
    property Rect1: TRect read FRect1 write FRect1;
    property Rect2: TRect read FRect2 write FRect2;
  published
    property ID: integer read FID write FID;
  end;

procedure TMyComponent.DefineProperties(Filer: TFiler);
begin
  inherited DefineProperties(Filer);
  DefineRectProperty(Filer,'Rect1',@FRect1,nil);
  DefineRectProperty(Filer,'Rect2',@FRect2,nil);
end;

Diese Komponente kann nun gespeichert, geladen oder von den RTTI Bedienelementen verwendet werden. Sie müssen keinen weiteren Code schreiben.

Writing and Reading components from/to LFM

Beispiele finden Sie in der unit lresources : function ReadComponentFromTextStream und writeComponentAsTextToStream

Writing and Reading components from/to XML

Streaming components ist einfach: Siehe das Beispiel in lazarus/examples/xmlstreaming/.

Fazit

RTTI ist ein leistungsstarker Mechanismus, der verwendet werden kann, um einfach ganze Klassen zu streamen, und er hilft das Schreiben von langweiligem Laden/Speichern Code zu vermeiden.

Siehe auch