Executing External Programs/nl: what changed

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

Old	New		Line
1	1		## Inleiding
2	2
3	3		Er zijn verschillende manieren om een extern programma uit te laten voeren. We richten ons nu op een manier, namelijk het gebruik van TProcess.
4	4
5	5		PAS OP!
6	6
7	7		De getoonde code is te simpel, het werkt wel maar de originele auteur wijst er op dat het programma op deze manier kan "hangen", wil je weten hoe e.e.a. goed gedaan moet worden lees dan de Engelse versie. Als ik de tijd weer heb zal ik een goede Nederlandse tekst produceren. Een opmerking naar de auteur van deze tekst: Prima dat je wilt vertalen, maar doe het dan zo exact en volledig mogelijk.
8	8
9	9		## TProcess
10	10
11	11		TProcess wordt gebruikt om een extern programma uit te laten voeren. Een paar voordelen van het gebruik van TProcess boven andere manieren zijn:
12	12
13	13		- Platform onafhankelijk.
14	14		- Het geeft ook de mogelijkheid om te schrijven naar stdout en te lezen van stdin.
15	15
16	16		### Een eenvoudig voorbeeld
17	17
18	18		`// Dit is een demo prograamma dat laat zien hoe je`\
19	19		`// een extern programma kunt uitvoeren.`\
20	20		`program launchprogram;`\
21		-	\
	21	+
22	22		`// De te gebruiken units. `\
23	23		`uses `\
24	24		` Classes, SysUtils, Process;`\
25		-	\
	25	+
26	26		`// Hier definieren we de variabele aProcess van het`\
27	27		`// type "TProcess"`\
28	28		`var `\
29	29		` aProcess: TProcess;`\
30		-	\
	30	+
31	31		`// Hier begint ons programma`\
32	32		`begin`\
33	33		` // Allereerst maken we een instantie van het TProcess`\
34	34		` // object en kennen dat toe aan aProcess`\
35	35		` aProcess := TProcess.Create(nil);`\
36		-	\
	36	+
37	37		` // Welk commando gaan we uitvoeren?`\
38	38		` // Voor deze keer voeren we de FPC compiler uit.`\
39	39		` AProcess.CommandLine := 'ppc386 -h';`\
40		-	\
	40	+
41	41		` // Nu definieren we wat er moet gebeuren nadat het`\
42	42		` // programma is gestart. In dit geval wachten we met`\
43	43		` // ons programma totdat het gestarte programma is `\
44	44		` // afgelopen. vvvvvvvvvvvvvv`\
45	45		` AProcess.Options := AProcess.Options + [poWaitOnExit];`\
46		-	\
	46	+
47	47		` // Nu weet aProcess wat er moet gebeuren, dus laten`\
48	48		` // we het uitvoeren.`\
49	49		` AProcess.Execute;`\
50		-	\
	50	+
51	51		` // Hier komen we dus pas als ppc386 gestopt is.`\
52	52		` AProcess.Free; `\
53	53		`end.`
54	54
55	55		Simpel he! Je hebt nu gezien hoe je een ander programma kunt uitvoeren vanuit je eigen programma!
56	56
57	57		Dat is wel leuk, maar hoe kan ik de output van een programma dan opvangen, zodat ik er wat mee kan doen?
58	58
59	59		Goed om dat te laten zien, zullen we het voorbeeld een beetje uitbreiden:
60	60
61	61		### Een uitgebreider voorbeeld
62	62
63	63		`// Dit is een demo programma dat laat zien hoe je een`\
64	64		`// extern programma kunt uitvoeren en de uitvoer opvangen.`\
65	65		`program launchprogram;`\
66		-	\
	66	+
67	67		`// De te gebruiken units`\
68	68		`uses `\
69	69		` Classes, SysUtils, Process;`\
70		-	\
	70	+
71	71		`// We definieren nu een extra variabele erbij om de uitvoer`\
72	72		`// van het uitgevoerde programma op te slaan.`\
73	73		`var `\
74	74		` AProcess: TProcess;`\
75	75		` AStringList: TStringList;`\
76		-	\
	76	+
77	77		`// Hier begint ons programma`\
78	78		`begin`\
79	79		` // Allereerst maken we een instantie van het TProcess`\
80	80		` // object en kennen dat toe aan aProcess`\
81	81		` AProcess := TProcess.Create(nil);`\
82		-	\
	82	+
83	83		` // Het TStringList object maken.`\
84	84		` AStringList := TStringList.Create;`\
85		-	\
	85	+
86	86		` // Welk commando gaan we uitvoeren?`\
87	87		` // Voor deze keer voeren we de FPC compiler uit.`\
88	88		` AProcess.CommandLine := 'ppc386 -h';`\
89		-	\
	89	+
90	90		` // Nu definieren we wat er moet gebeuren nadat het`\
91	91		` // programma is gestart. In dit geval wachten we met`\
92	92		` // ons programma totdat het gestarte programma is `\
93	93		` // afgelopen. vvvvvvvvvvvvvv`\
94	94		` AProcess.Options := AProcess.Options + [poWaitOnExit, poUsePipes];`\
95		-	\
	95	+
96	96		` // Nu weet aProcess wat er moet gebeuren, dus laten`\
97	97		` // we het uitvoeren.`\
98	98		` AProcess.Execute;`\
99	99		` `\
100	100		` // Hier komen we oas als ppc386 gestopt is.`\
101		-	\
	101	+
102	102		` // Nu gaan we de uitvoer van het programma opslaan`\
103	103		` // in de TStringList.`\
104	104		` AStringList.Lines.ReadFromStream(AProcess.Output);`\
105	105		` `\
106	106		` // Dit slaan we dan weer op in een bestand.`\
107	107		` AStringList.Lines.SaveToFile('c:\output.txt');`\
108		-	\
	108	+
109	109		` // En dan nu de stringlist en het process weer vrijgeven.`\
110	110		` AStringList.Free;`\
111	111		` AProcess.Free; `\
112	112		`end.`
113	113
114	114		---
115	115		From the Free Pascal wiki, page "Executing External Programs/nl", as it stood on 2013-03-17 after a change by Vitron, 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).

Back to history