Crearea componentelor dinamic (la timpul de execuție)

Cel mai adesea atunci când programați în Delphi nu este necesar să creați dinamic o componentă. Dacă renunțați la o componentă pe un formular, Delphi gestionează automat crearea componentelor atunci când este creat formularul. Acest articol va acoperi modul corect de a crea programatic componente în timpul rulării.

Crearea componentelor dinamice

Există două moduri de a crea în mod dinamic componente. Un mod este de a face un formular (sau un alt TComponent) proprietarul noii componente. Aceasta este o practică obișnuită atunci când construiți componente compuse în care un container vizual creează și deține subcomponentele. Dacă faceți acest lucru, vă veți asigura că componenta recent creată este distrusă atunci când componenta proprietar este distrusă.

Pentru a crea o instanță (obiect) a unei clase, apelați la metoda „Creare”. Creatorul constructor este o metodă de clasă, spre deosebire de practic toate celelalte metode pe care le veți întâlni în programarea Delphi, care sunt metode obiect.

De exemplu, TComponent declară constructorul Create astfel:

constructor Creare (AOwner: TComponent); virtual;

Creație dinamică cu proprietarii
Iată un exemplu de creație dinamică, unde De sine este un descendent TComponent sau TComponent (de exemplu, o instanță a unui TForm):

cu TTimer.Create (Self) do
începe
Interval: = 1000;
Activat: = Fals;
OnTimer: = MyTimerEventHandler;
Sfârșit;

Creare dinamică cu un apel explicit la liber
Al doilea mod de a crea o componentă este de a utiliza zero în calitate de proprietar. Rețineți că, dacă faceți acest lucru, trebuie să eliberați explicit și obiectul pe care îl creați de îndată ce nu mai aveți nevoie de el (sau veți produce o scurgere de memorie). Iată un exemplu de utilizare a nil ca proprietar:

cu TTable.Create (nil) do
încerca
DataBaseName: = 'MyAlias';
TableName: = 'MyTable';
Deschis;
Editați | ×;
FieldByName („Ocupat”). AsBoolean: = True;
Post;
in cele din urma
Liber;
Sfârșit;

Creare dinamică și referințe de obiecte
Este posibil să îmbunătățiți cele două exemple anterioare, alocând rezultatul apelului Creare unei variabile locale metodei sau aparținând clasei. Acest lucru este adesea de dorit atunci când trebuie utilizate mai târziu referințe la componentă sau atunci când trebuie evitate problemele de abordare potențial cauzate de blocurile „Cu”. Iată codul de creare TTimer de mai sus, folosind o variabilă de câmp ca referință la obiectul TTimer inițiat:

FTimer: = TTimer.Create (Self);
cu FTimer do
începe
Interval: = 1000;
Activat: = Fals;
OnTimer: = MyInternalTimerEventHandler;
Sfârșit;

În acest exemplu, "FTimer" este o variabilă de câmp privat a formei sau a containerului vizual (sau orice este „Sinele”). Când accesați variabila FTimer din metodele din această clasă, este foarte bună să verificați pentru a vedea dacă referința este valabilă înainte de a o utiliza. Aceasta se face folosind funcția Delphi Assigned:

dacă Assigned (FTimer), atunci FTimer.Enabled: = True;

Creare dinamică și referințe de obiect fără proprietari
O variantă este crearea componentei fără proprietar, dar menținerea referinței pentru distrugerea ulterioară. Codul de construcție pentru TTimer ar arăta astfel:

FTimer: = TTimer.Create (nil);
cu FTimer do
începe
...
Sfârșit;

Iar codul de distrugere (probabil în distrugătorul formei) ar arăta astfel: