Skapa komponenter dynamiskt (vid körning)

Oftast när du programmerar i Delphi behöver du inte dynamiskt skapa en komponent. Om du släpper en komponent på ett formulär, hanterar Delphi komponentskapningen automatiskt när formuläret skapas. Den här artikeln kommer att täcka rätt sätt att programmatiskt skapa komponenter vid körning.

Skapa dynamisk komponent

Det finns två sätt att dynamiskt skapa komponenter. Ett sätt är att skapa ett formulär (eller någon annan TComponent) till ägaren av den nya komponenten. Detta är vanligt när man bygger kompositkomponenter där en visuell behållare skapar och äger underkomponenterna. Om du gör det kommer du att säkerställa att den nyskapade komponenten förstörs när den ägande komponenten förstörs.

För att skapa en instans (objekt) för en klass, kallar du metoden "Skapa". Skapa konstruktören är en klassmetod, till skillnad från praktiskt taget alla andra metoder du kommer att stöta på i Delphi-programmering, som är objektmetoder.

Till exempel förklarar TComponenten Skapa konstruktören enligt följande:

konstruktör Skapa (AOwner: TComponent); virtuell;

Dynamisk skapelse med ägare
Här är ett exempel på dynamisk skapelse, där Själv är en TComponent- eller TComponent-efterkommer (t.ex. en förekomst av en TForm):

med TTimer.Create (Själv) göra
Börja
Intervall: = 1000;
Aktiverad: = Falsk;
OnTimer: = MyTimerEventHandler;
slutet;

Dynamisk skapelse med ett uttryckligt samtal till gratis
Det andra sättet att skapa en komponent är att använda noll som ägare. Observera att om du gör detta måste du också fritt frigöra objektet du skapar så snart du inte längre behöver det (eller så kommer du att skapa en minnesläcka). Här är ett exempel på att använda nil som ägare:

med TTable.Create (noll) gör
Prova
DataBaseName: = 'MyAlias';
Tabellnamn: = 'MyTable';
Öppen;
Redigera;
FieldByName ('Upptagen'). AsBoolean: = True;
Posta;
till sist
Fri;
slutet;

Dynamisk skapelse och objektreferenser
Det är möjligt att förbättra de två tidigare exemplen genom att tilldela resultatet av Skapa samtal till en variabel lokal till metoden eller som tillhör klassen. Detta är ofta önskvärt när referenser till komponenten behöver användas senare, eller när scopingproblem som kan orsakas av "With" -block behöver undvikas. Här är TTimer-skapelseskoden ovanifrån och använder en fältvariabel som referens till det instanserade TTimer-objektet:

FTimer: = TTimer.Create (Själv);
med FTimer do
Börja
Intervall: = 1000;
Aktiverad: = Falsk;
OnTimer: = MyInternalTimerEventHandler;
slutet;

I detta exempel är "FTimer" en privat fältvariabel av formen eller den visuella behållaren (eller vad "Själv" är). När du använder FTimer-variabeln från metoder i den här klassen är det en mycket bra idé att kontrollera om referensen är giltig innan du använder den. Detta görs med hjälp av Delphis tilldelade funktion:

om Tilldelad (FTimer) är FTimer.Enabled: = Sann;

Dynamisk skapelse och objektreferenser utan ägare
En variation på detta är att skapa komponenten utan ägare, men behålla referensen för senare förstörelse. Konstruktionskoden för TTimer ser ut så här:

FTimer: = TTimer. Skapa (noll);
med FTimer do
Börja
...
slutet;

Och förstöringskoden (antagligen i formens förstörare) skulle se ut så här: