Streaming components/de: what changed

Revision 2 to 3. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		Zurück zu den [[Additional information/de\|Zusätzlichen Informationen]].\
2	2
3	3		== Einleitung ==
4	4
5	5		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.
6	6
7	7		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.
8	8
9		-	~~` Siehe <lazaruspath>/examples/componentstreaming/`~~
	9	+	```text
	10	+	Siehe <lazaruspath>/examples/componentstreaming/
	11	+	```
10	12
11	13		In Kombination mit [[RTTI controls/de\|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.
12	14
13	15		## TComponent / TPersistent
14	16
15	17		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.
16	18
17	19		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.
18	20
19	21		## TReader / TWriter
20	22
21	23		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.
22	24
23	25		## Schreiben ihrer eigenen Komponente - Teil 1
24	26
25	27		Eine maßgeschneiderte Komponente kann so einfach sein wie:
26	28
27	29		```delphi
28	30
29	31		type
30	32		TMyComponent = class(TComponent)
31	33		private
32	34		FID: integer;
33	35		published
34	36		property ID: integer read FID write FID;
35	37		end;
36	38		```
37	39
38	40		## Schreiben einer Komponente in einen Stream
39	41
40	42		Die Unit [[doc:lcl/lresources\|LResources]] hat eine Funktion dafür:
41	43
42	44		```delphi
43	45		procedure WriteComponentAsBinaryToStream(AStream: TStream; AComponent: TComponent);
44	46		```
45	47
46	48		Sie schreibt eine Komponente im binären Format in den Stream. Zum Beispiel:
47	49
48	50		```delphi
49	51		procedure TForm1.Button1Click(Sender: TObject);
50	52		var
51	53		AStream: TMemoryStream;
52	54		begin
53	55		AStream:=TMemoryStream.Create;
54	56		try
55	57		WriteComponentAsBinaryToStream(AStream,AGroupBox);
56	58		// ... Stream weiterverarbeiten oder abspeichern ...
57	59		finally
58	60		AStream.Free;
59	61		end;
60	62		end;
61	63		```
62	64
63	65		## Lesen einer Komponente aus einem Stream
64	66
65	67		Die Unit LResources hat eine Funktion dafür:
66	68
67	69		```delphi
68	70		procedure ReadComponentFromBinaryStream(AStream: TStream;
69	71		var RootComponent: TComponent; OnFindComponentClass: TFindComponentClassEvent; TheOwner: TComponent = nil);
70	72		```
71	73
72	74		- AStream ist der Stream, der eine Komponente im binären Format enthält.
73	75		- RootComponent ist entweder eine existierende Komponente, deren Daten überschrieben werden, oder ist null und eine neue Komponente wird erzeugt.
74	76		- OnFindComponentClass ist eine Funktion, die von TReader verwendet wird, um die Klasse aus den Klassennamen im Stream zu erhalten. Zum Beispiel:
75	77
76	78		```delphi
77	79		procedure TCompStreamDemoForm.OnFindClass(Reader: TReader;
78	80		const AClassName: string; var ComponentClass: TComponentClass);
79	81		begin
80	82		if CompareText(AClassName,'TGroupBox')=0 then
81	83		ComponentClass:=TGroupBox
82	84		else if CompareText(AClassName,'TCheckBox')=0 then
83	85		ComponentClass:=TCheckBox;
84	86		end;
85	87		```
86	88
87	89		- TheOwner is the component owner, when creating a new component.
88	90
89	91		## Streambare Eigenschaften
90	92
91	93		Es gibt einige Einschränkungen, welche Typen TReader/TWriter streamen kann:
92	94
93	95		- Basistypen können gestreamt werden: string, integer, char, single, double, extended, byte, word, cardinal, shortint, method pointers, etc. .
94	96		- TPersistent und Nachfahren können gestreamt werden
95	97
96	98		- 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.
97	99
98	100		## Streaming custom Data - DefineProperties
99	101
100	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:
101	103
102	104		```delphi
103	105		procedure DefineProperties(Filer: TFiler); override;
104	106		procedure ReadMyRect(Reader: TReader);
105	107		procedure WriteMyRect(Writer: TWriter);
106	108		```
107	109
108	110		mit dem folgenden Code:
109	111
110	112		```delphi
111	113		procedure TMyComponent.DefineProperties(Filer: TFiler);
112	114		var
113	115		MyRectMustBeSaved: Boolean;
114	116		begin
115	117		inherited DefineProperties(Filer);
116	118		MyRectMustBeSaved:=(MyRect.Left<>0)
117	119		or (MyRect.Top<>0)
118	120		or (MyRect.Right<>0)
119	121		or (MyRect.Bottom<>0);
120	122		Filer.DefineProperty('MyRect',@ReadMyRect,@WriteMyRect,MyRectMustBeSaved);
121	123		end;
122	124
123	125		procedure TMyComponent.ReadMyRect(Reader: TReader);
124	126		begin
125	127		with Reader do begin
126	128		ReadListBegin;
127	129		FMyRect.Left:=ReadInteger;
128	130		FMyRect.Top:=ReadInteger;
129	131		FMyRect.Right:=ReadInteger;
130	132		FMyRect.Bottom:=ReadInteger;
131	133		ReadListEnd;
132	134		end;
133	135		end;
134	136
135	137		procedure TMyComponent.WriteMyRect(Writer: TWriter);
136	138		begin
137	139		with Writer do begin
138	140		WriteListBegin;
139	141		WriteInteger(FMyRect.Left);
140	142		WriteInteger(FMyRect.Top);
141	143		WriteInteger(FMyRect.Right);
142	144		WriteInteger(FMyRect.Bottom);
143	145		WriteListEnd;
144	146		end;
145	147		end;
146	148		```
147	149
148	150		Dies wird MyRect als Eigenschaft 'MyRect' speichern.
149	151
150	152		Falls Sie oft TRect streamen , dann wollen sie wahrscheinlich nicht jedes Mal den ganzen Code schreiben.
151	153
152	154		Die Unit LResources enthält ein Beispiel, wie man eine Prozedur schreibt, um eine rect Eigenschaft zu definieren:
153	155
154	156		```delphi
155	157		procedure DefineRectProperty(Filer: TFiler; const Name: string; ARect, DefaultRect: PRect);
156	158		```
157	159
158	160		Auf diese Art kann der obige Code kurz gehalten werden :
159	161
160	162		```delphi
161	163		procedure TMyComponent.DefineProperties(Filer: TFiler);
162	164		begin
163	165		inherited DefineProperties(Filer);
164	166		DefineRectProperty(Filer,'MyRect',@FMyRect,nil);
165	167		end;
166	168		```
167	169
168	170		## Schreiben ihrer eigenen Komponente - Teil 2
169	171
170	172		Jetzt kann das Beispiel erweitert werden und wir können beliebige Eigenschaften verwenden mit nur ein paar Zeilen Code:
171	173
172	174		```delphi
173	175		type
174	176		TMyComponent = class(TComponent)
175	177		private
176	178		FID: integer;
177	179		FRect1: TRect;
178	180		FRect2: TRect;
179	181		protected
180	182		procedure DefineProperties(Filer: TFiler); override;
181	183		public
182	184		property Rect1: TRect read FRect1 write FRect1;
183	185		property Rect2: TRect read FRect2 write FRect2;
184	186		published
185	187		property ID: integer read FID write FID;
186	188		end;
187	189
188	190		procedure TMyComponent.DefineProperties(Filer: TFiler);
189	191		begin
190	192		inherited DefineProperties(Filer);
191	193		DefineRectProperty(Filer,'Rect1',@FRect1,nil);
192	194		DefineRectProperty(Filer,'Rect2',@FRect2,nil);
193	195		end;
194	196		```
195	197
196	198		Diese Komponente kann nun gespeichert, geladen oder von den [[RTTI controls/de\|RTTI Bedienelementen]] verwendet werden. Sie müssen keinen weiteren Code schreiben.
197	199
198	200		## Writing and Reading components from/to LFM
199	201
200	202		Beispiele finden Sie in der unit lresources : function ReadComponentFromTextStream und writeComponentAsTextToStream
201	203
202	204		## Writing and Reading components from/to XML
203	205
204	206		Streaming components ist einfach: Siehe das Beispiel in lazarus/examples/xmlstreaming/.
205	207
206	208		## Fazit
207	209
208	210		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.
209	211
210	212		## Siehe auch
211	213
212	214		- [[RTTI controls/de\|RTTI controls]]
213	215
214	216		---
215	217		From the Free Pascal wiki, page "Streaming components/de", as it stood on 2014-05-07 after a change by Socke, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).
216	218		Category: Components/de
217	219		Category: Deutsch
218	220		Category: Tutorials/de

Back to history