Sign in Join
Wiki copytemporary

Executing External Programs/nl: what changed

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

OldNewLine
11## Inleiding
22
33Er zijn verschillende manieren om een extern programma uit te laten voeren. We richten ons nu op een manier, namelijk het gebruik van TProcess.
44
55PAS OP!
66
77De 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.
88
99## TProcess
1010
1111TProcess wordt gebruikt om een extern programma uit te laten voeren. Een paar voordelen van het gebruik van TProcess boven andere manieren zijn:
1212
1313- Platform onafhankelijk.
1414- Het geeft ook de mogelijkheid om te schrijven naar stdout en te lezen van stdin.
1515
1616### Een eenvoudig voorbeeld
1717
18-`// Dit is een demo prograamma dat laat zien hoe je`\
19-`// een extern programma kunt uitvoeren.`\
20-`program launchprogram;`\
18+``` pascal
19+// Dit is een demo prograamma dat laat zien hoe je
20+// een extern programma kunt uitvoeren.
21+program launchprogram;
2122
22-`// De te gebruiken units. `\
23-`uses `\
24-`  Classes, SysUtils, Process;`\
23+// De te gebruiken units.
24+uses
25+ Classes, SysUtils, Process;
2526
26-`// Hier definieren we de variabele aProcess van het`\
27-`// type "TProcess"`\
28-`var `\
29-`  aProcess: TProcess;`\
27+// Hier definieren we de variabele aProcess van het
28+// type "TProcess"
29+var
30+ aProcess: TProcess;
3031
31-`// Hier begint ons programma`\
32-`begin`\
33-`  // Allereerst maken we een instantie van het TProcess`\
34-`  // object en kennen dat toe aan aProcess`\
35-`  aProcess := TProcess.Create(nil);`\
32+// Hier begint ons programma
33+begin
34+ // Allereerst maken we een instantie van het TProcess
35+ // object en kennen dat toe aan aProcess
36+ aProcess := TProcess.Create(nil);
3637
37-`  // Welk commando gaan we uitvoeren?`\
38-`  // Voor deze keer voeren we de FPC compiler uit.`\
39-`  AProcess.CommandLine := 'ppc386 -h';`\
38+ // Welk commando gaan we uitvoeren?
39+ // Voor deze keer voeren we de FPC compiler uit.
40+ AProcess.CommandLine := 'ppc386 -h';
4041
41-`  // Nu definieren we wat er moet gebeuren nadat het`\
42-`  // programma is gestart. In dit geval wachten we met`\
43-`  // ons programma totdat het gestarte programma is    `\
44-`  // afgelopen.                          vvvvvvvvvvvvvv`\
45-`  AProcess.Options := AProcess.Options + [poWaitOnExit];`\
42+ // Nu definieren we wat er moet gebeuren nadat het
43+ // programma is gestart. In dit geval wachten we met
44+ // ons programma totdat het gestarte programma is
45+ // afgelopen. vvvvvvvvvvvvvv
46+ AProcess.Options := AProcess.Options + [poWaitOnExit];
4647
47-`  // Nu weet aProcess wat er moet gebeuren, dus laten`\
48-`  // we het uitvoeren.`\
49-`  AProcess.Execute;`\
48+ // Nu weet aProcess wat er moet gebeuren, dus laten
49+ // we het uitvoeren.
50+ AProcess.Execute;
5051
51-`  // Hier komen we dus pas als ppc386 gestopt is.`\
52-`  AProcess.Free;   `\
53-`end.`
52+ // Hier komen we dus pas als ppc386 gestopt is.
53+ AProcess.Free;
54+end.
55+```
5456
5557Simpel he! Je hebt nu gezien hoe je een ander programma kunt uitvoeren vanuit je eigen programma!
5658
5759Dat is wel leuk, maar hoe kan ik de output van een programma dan opvangen, zodat ik er wat mee kan doen?
5860
5961Goed om dat te laten zien, zullen we het voorbeeld een beetje uitbreiden:
6062
6163### Een uitgebreider voorbeeld
6264
63-`// Dit is een demo programma dat laat zien hoe je een`\
64-`// extern programma kunt uitvoeren en de uitvoer opvangen.`\
65-`program launchprogram;`\
65+``` pascal
66+// Dit is een demo programma dat laat zien hoe je een
67+// extern programma kunt uitvoeren en de uitvoer opvangen.
68+program launchprogram;
6669
67-`// De te gebruiken units`\
68-`uses `\
69-`  Classes, SysUtils, Process;`\
70+// De te gebruiken units
71+uses
72+ Classes, SysUtils, Process;
7073
71-`// We definieren nu een extra variabele erbij om de uitvoer`\
72-`// van het uitgevoerde programma op te slaan.`\
73-`var `\
74-`  AProcess: TProcess;`\
75-`  AStringList: TStringList;`\
74+// We definieren nu een extra variabele erbij om de uitvoer
75+// van het uitgevoerde programma op te slaan.
76+var
77+ AProcess: TProcess;
78+ AStringList: TStringList;
7679
77-`// Hier begint ons programma`\
78-`begin`\
79-`  // Allereerst maken we een instantie van het TProcess`\
80-`  // object en kennen dat toe aan aProcess`\
81-`  AProcess := TProcess.Create(nil);`\
80+// Hier begint ons programma
81+begin
82+ // Allereerst maken we een instantie van het TProcess
83+ // object en kennen dat toe aan aProcess
84+ AProcess := TProcess.Create(nil);
8285
83-`  // Het TStringList object maken.`\
84-`  AStringList := TStringList.Create;`\
86+ // Het TStringList object maken.
87+ AStringList := TStringList.Create;
8588
86-`  // Welk commando gaan we uitvoeren?`\
87-`  // Voor deze keer voeren we de FPC compiler uit.`\
88-`  AProcess.CommandLine := 'ppc386 -h';`\
89+ // Welk commando gaan we uitvoeren?
90+ // Voor deze keer voeren we de FPC compiler uit.
91+ AProcess.CommandLine := 'ppc386 -h';
8992
90-`  // Nu definieren we wat er moet gebeuren nadat het`\
91-`  // programma is gestart. In dit geval wachten we met`\
92-`  // ons programma totdat het gestarte programma is    `\
93-`  // afgelopen.                          vvvvvvvvvvvvvv`\
94-`  AProcess.Options := AProcess.Options + [poWaitOnExit, poUsePipes];`\
93+ // Nu definieren we wat er moet gebeuren nadat het
94+ // programma is gestart. In dit geval wachten we met
95+ // ons programma totdat het gestarte programma is
96+ // afgelopen. vvvvvvvvvvvvvv
97+ AProcess.Options := AProcess.Options + [poWaitOnExit, poUsePipes];
9598
96-`  // Nu weet aProcess wat er moet gebeuren, dus laten`\
97-`  // we het uitvoeren.`\
98-`  AProcess.Execute;`\
99-` `\
100-`  // Hier komen we oas als ppc386 gestopt is.`\
99+ // Nu weet aProcess wat er moet gebeuren, dus laten
100+ // we het uitvoeren.
101+ AProcess.Execute;
102+
103+ // Hier komen we oas als ppc386 gestopt is.
101104
102-`  // Nu gaan we de uitvoer van het programma opslaan`\
103-`  // in de TStringList.`\
104-`  AStringList.Lines.ReadFromStream(AProcess.Output);`\
105-`  `\
106-`  // Dit slaan we dan weer op in een bestand.`\
107-`  AStringList.Lines.SaveToFile('c:\output.txt');`\
105+ // Nu gaan we de uitvoer van het programma opslaan
106+ // in de TStringList.
107+ AStringList.Lines.ReadFromStream(AProcess.Output);
108+
109+ // Dit slaan we dan weer op in een bestand.
110+ AStringList.Lines.SaveToFile('c:\output.txt');
108111
109-`  // En dan nu de stringlist en het process weer vrijgeven.`\
110-`  AStringList.Free;`\
111-`  AProcess.Free;   `\
112-`end.`
112+ // En dan nu de stringlist en het process weer vrijgeven.
113+ AStringList.Free;
114+ AProcess.Free;
115+end.
116+```
113117
114118---
115119*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