Streaming components/de: what changed

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

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

Back to history