Componenten dynamisch maken (tijdens runtime)

Meestal hoeft u bij het programmeren in Delphi niet dynamisch een component te maken. Als u een component op een formulier neerzet, verwerkt Delphi de componentcreatie automatisch wanneer het formulier wordt gemaakt. Dit artikel behandelt de juiste manier om programmatisch componenten te maken tijdens runtime.

Creatie van dynamische componenten

Er zijn twee manieren om componenten dynamisch te maken. Een manier is om een ​​formulier (of een andere TComponent) eigenaar te maken van de nieuwe component. Dit is een gebruikelijke praktijk bij het bouwen van samengestelde componenten waarbij een visuele container de subcomponenten maakt en bezit. Als u dit doet, zorgt u ervoor dat de nieuw gemaakte component wordt vernietigd wanneer de eigen component wordt vernietigd.

Om een ​​instantie (object) van een klasse te maken, noemt u de "Create" -methode. De Create-constructor is een klassemethode, in tegenstelling tot vrijwel alle andere methoden die u tegenkomt in Delphi-programmering, die objectmethoden zijn.

De TComponent verklaart de Create-constructor bijvoorbeeld als volgt:

constructor Maken (AOwner: TComponent); virtual;

Dynamische creatie met eigenaren
Hier is een voorbeeld van dynamische creatie, waar Zelf is een TComponent of TComponent-afstammeling (bijvoorbeeld een instantie van een TForm):

met TTimer.Create (Zelf) doen
beginnen
Interval: = 1000;
Ingeschakeld: = False;
OnTimer: = MyTimerEventHandler;
einde;

Dynamische creatie met een expliciete gratis oproep
De tweede manier om een ​​component te maken is om te gebruiken nul als de eigenaar. Merk op dat als u dit doet, u ook het object dat u maakt expliciet moet bevrijden zodra u het niet langer nodig hebt (of u zult een geheugenlek produceren). Hier is een voorbeeld van het gebruik van nul als de eigenaar:

met TTable.Create (nihil) doen
proberen
DataBaseName: = 'MyAlias';
TableName: = 'MyTable';
Open;
Bewerk;
FieldByName ('Busy'). AsBoolean: = True;
Post;
Tenslotte
Vrij;
einde;

Dynamische creatie en objectreferenties
Het is mogelijk om de twee voorgaande voorbeelden te verbeteren door het resultaat van de aanroep Create aan een variabele toe te wijzen die lokaal is voor de methode of die tot de klasse behoort. Dit is vaak wenselijk wanneer verwijzingen naar de component later moeten worden gebruikt, of wanneer scopingproblemen die mogelijk worden veroorzaakt door "With" -blokken moeten worden vermeden. Hier is de TTimer-aanmaakcode van hierboven, met behulp van een veldvariabele als referentie naar het instantiërde TTimer-object:

FTimer: = TTimer.Create (Zelf);
met FTimer doen
beginnen
Interval: = 1000;
Ingeschakeld: = False;
OnTimer: = MyInternalTimerEventHandler;
einde;

In dit voorbeeld is "FTimer" een variabele van het privéveld met de vorm of visuele container (of wat "Zelf" ook is). Wanneer u de FTimer-variabele opent vanuit methoden in deze klasse, is het een goed idee om te controleren of de referentie geldig is voordat u deze gebruikt. Dit wordt gedaan met behulp van de toegewezen functie van Delphi:

indien toegewezen (FTimer) dan FTimer.Enabled: = True;

Dynamische creatie en objectreferenties zonder eigenaren
Een variatie hierop is om de component te maken zonder eigenaar, maar de referentie te behouden voor latere vernietiging. De constructiecode voor de TTimer ziet er als volgt uit:

FTimer: = TTimer.Create (nul);
met FTimer doen
beginnen
...
einde;

En de vernietigingscode (vermoedelijk in de destructor van de vorm) zou er ongeveer zo uitzien: