Skapa Delphi-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.

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. Skapa (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 producera ett minnesförlust). Här är ett exempel på att använda nil som ägare:

med TTable. Skapa (noll) do
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å föregående 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 komponent behöver användas senare, eller när avgränsning problem som kan orsakas av "With" -block måste undvikas. Här är TTimer-skapelsekoden från ovan med en fältvariabel som referens till det instanserade TTimer-objektet:

FTimer: = TTimer. Skapa (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) så FTimer. Aktiverad: = 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:

FTimer. Fri;
FTimer: = noll;
(*
Eller använd FreeAndNil-proceduren (FTimer), som frigör en objektreferens och ersätter referensen med noll.
*)

Att ställa in objektets referens till noll är avgörande när du frigör objekt. Samtalet till Free kontrollerar först om objektreferensen är noll eller inte, och om den inte är det, kallar den objektets förstörare Destroy.

Här är TTable-skapelsekoden från ovan med en lokal variabel som referens till det instanserade TTable-objektet:

localTable: = TTable. Skapa (noll);
Prova
med localTable do
Börja
DataBaseName: = 'MyAlias';
Tabellnamn: = 'MyTable';
slutet;
...
// Senare, om vi uttryckligen vill specificera omfattning:
localTable. Öppen;
localTable. Redigera;
localTable. FieldByName ('Upptagen'). AsBoolean: = True;
localTable. Posta;
till sist
localTable. Fri;
localTable: = noll;
slutet;

I exemplet ovan är "localTable" en lokal variabel deklareras på samma metod som innehåller denna kod. Observera att det i allmänhet är en bra idé att ställa in referensen till noll efter att ha frigjort något objekt.

VIKTIGT: Blanda inte ett samtal till Free med att skicka en giltig ägare till konstruktören. Alla tidigare tekniker fungerar och är giltiga, men följande bör förekommer aldrig i din kod:

med TTable. Skapa (själv) göra
Prova
...
till sist
Fri;
slutet;

Kodexemplet ovan introducerar onödiga prestandahits, påverkar minnet något och har potential att introducera svåra att hitta buggar. Ta reda på varför.

Obs: Om en dynamiskt skapad komponent har en ägare (specificerad av AOwner-parametern i Skapa konstruktören), är den ägaren ansvarig för att förstöra komponenten. Annars måste du uttryckligen ringa gratis när du inte längre behöver komponenten.

_{Artikel ursprungligen skriven av Mark Miller}

Ett testprogram skapades i Delphi för att tidpunkten för den dynamiska skapandet av 1000 komponenter med olika initiala komponenträkningar. Testprogrammet visas längst ner på denna sida. Diagrammet visar en uppsättning resultat från testprogrammet och jämför tiden det tar för att skapa komponenter både med ägare och utan. Observera att detta bara är en del av hiten. En liknande prestationsfördröjning kan förväntas när komponenter förstörs. Tiden att dynamiskt skapa komponenter med ägare är 1200% till 107960% långsammare än den att skapa komponenter utan ägare, beroende på antalet komponenter på formuläret och komponenten som är skapats.

Varning: Det här testprogrammet spårar inte och frigör komponenter som skapas utan ägare. Genom att inte spåra och frigöra dessa komponenter återspeglar tider som mäts för den dynamiska skapelseskoden mer exakt realtid för att dynamiskt skapa en komponent.

Ladda ner källkod

Om du vill dynamiskt instansera en Delphi-komponent och uttryckligen frigöra den någon gång senare, passera alltid nil som ägare. Underlåtenhet att göra detta kan medföra onödiga risker samt problem med prestanda och kodunderhåll. Läs artikeln "En varning om dynamisk inställning av Delphi-komponenter" för att lära dig mer ...