Creazione dinamica di componenti (in fase di esecuzione)

Molto spesso durante la programmazione in Delphi non è necessario creare dinamicamente un componente. Se si rilascia un componente su un modulo, Delphi gestisce automaticamente la creazione del componente quando viene creato il modulo. Questo articolo illustrerà il modo corretto di creare a livello di codice componenti in fase di esecuzione.

Creazione dinamica di componenti

Esistono due modi per creare dinamicamente componenti. Un modo è rendere un modulo (o qualche altro TComponent) il proprietario del nuovo componente. Questa è una pratica comune quando si creano componenti compositi in cui un contenitore visivo crea e possiede i sottocomponenti. In questo modo si garantisce che il componente appena creato venga distrutto quando viene distrutto il componente proprietario.

Per creare un'istanza (oggetto) di una classe, si chiama il suo metodo "Crea". Il costruttore Create è un metodo di classe, al contrario di praticamente tutti gli altri metodi che incontrerai nella programmazione Delphi, che sono metodi oggetto.

Ad esempio, TComponent dichiara il costruttore Create come segue:

costruttore create (AOwner: TComponent); virtuale;

Creazione dinamica con i proprietari
Ecco un esempio di creazione dinamica, dove Se stesso è un discendente TComponent o TComponent (ad esempio un'istanza di un TForm):

con TTimer.Create (Self) fare
inizio
Intervallo: = 1000;
Abilitato: = Falso;
OnTimer: = MyTimerEventHandler;
fine;

Creazione dinamica con una chiamata esplicita a libero
Il secondo modo per creare un componente è utilizzare zero come il proprietario. Se lo fai, devi anche liberare esplicitamente l'oggetto che crei non appena non ti serve più (o produrrai una perdita di memoria). Ecco un esempio dell'utilizzo di zero come proprietario:

con TTable.Create (zero) do
provare
DataBaseName: = 'MyAlias';
TableName: = 'MyTable';
Aperto;
Modificare;
FieldByName ('Occupato'). AsBoolean: = True;
Inviare;
infine
Gratuito;
fine;

Creazione dinamica e riferimenti a oggetti
È possibile migliorare i due esempi precedenti assegnando il risultato della chiamata Crea a una variabile locale al metodo o appartenente alla classe. Ciò è spesso auspicabile quando i riferimenti al componente devono essere utilizzati in un secondo momento o quando è necessario evitare i problemi di scoping potenzialmente causati dai blocchi "Con". Ecco il codice di creazione TTimer dall'alto, usando una variabile di campo come riferimento all'oggetto TTimer istanziato:

FTimer: = TTimer.Create (Self);
con FTimer do
inizio
Intervallo: = 1000;
Abilitato: = Falso;
OnTimer: = MyInternalTimerEventHandler;
fine;

In questo esempio "FTimer" è una variabile di campo privata del modulo o contenitore visivo (o qualunque sia "Sé"). Quando si accede alla variabile FTimer dai metodi in questa classe, è una buona idea verificare se il riferimento è valido prima di usarlo. Questo viene fatto usando la funzione assegnata di Delphi:

se assegnato (FTimer) quindi FTimer.Enabled: = True;

Creazione dinamica e riferimenti a oggetti senza proprietari
Una variazione su questo è creare il componente senza proprietario, ma mantenere il riferimento per la distruzione successiva. Il codice di costruzione per il TTimer sarebbe simile al seguente:

FTimer: = TTimer.Create (zero);
con FTimer do
inizio
...
fine;

E il codice di distruzione (presumibilmente nel distruttore del modulo) sarebbe simile a questo: