Création dynamique de composants (au moment de l'exécution)

Le plus souvent, lors de la programmation dans Delphi, vous n'avez pas besoin de créer dynamiquement un composant. Si vous déposez un composant sur une fiche, Delphi gère automatiquement la création du composant lors de la création de la fiche. Cet article couvrira la façon correcte de créer des composants par programme au moment de l'exécution.

Création de composants dynamiques

Il existe deux façons de créer dynamiquement des composants. Une façon consiste à faire d'un formulaire (ou d'un autre composant TComponent) le propriétaire du nouveau composant. Il s'agit d'une pratique courante lors de la création de composants composites dans lesquels un conteneur visuel crée et possède les sous-composants. Cela garantira que le composant nouvellement créé est détruit lorsque le composant propriétaire est détruit.

Pour créer une instance (objet) d'une classe, vous appelez sa méthode "Create". Le constructeur Create est une méthode de classe, contrairement à pratiquement toutes les autres méthodes que vous rencontrerez dans la programmation Delphi, qui sont des méthodes objet.

Par exemple, le TComponent déclare le constructeur Create comme suit:

constructeur Create (AOwner: TComponent); virtuel;

Création dynamique avec les propriétaires
Voici un exemple de création dynamique, où Soi est un descendant de TComponent ou TComponent (par exemple, une instance d'un TForm):

avec TTimer.Create (Self) do
commencer
Intervalle: = 1000;
Activé: = False;
OnTimer: = MyTimerEventHandler;
fin;

Création dynamique avec un appel explicite à la gratuité
La deuxième façon de créer un composant consiste à utiliser néant en tant que propriétaire. Notez que si vous faites cela, vous devez également libérer explicitement l'objet que vous créez dès que vous n'en avez plus besoin (ou vous produirez une fuite de mémoire). Voici un exemple d'utilisation de nil en tant que propriétaire:

avec TTable.Create (nil) do
essayer
DataBaseName: = 'MyAlias';
TableName: = 'MyTable';
Ouvert;
Éditer;
FieldByName ('Occupé'). AsBoolean: = True;
Publier;
enfin
Gratuit;
fin;

Création dynamique et références d'objets
Il est possible d'améliorer les deux exemples précédents en affectant le résultat de l'appel Create à une variable locale à la méthode ou appartenant à la classe. Ceci est souvent souhaitable lorsque des références au composant doivent être utilisées ultérieurement, ou lorsque des problèmes de portée potentiellement causés par des blocs "Avec" doivent être évités. Voici le code de création TTimer ci-dessus, en utilisant une variable de champ comme référence à l'objet TTimer instancié:

FTimer: = TTimer.Create (Self);
avec FTimer do
commencer
Intervalle: = 1000;
Activé: = False;
OnTimer: = MyInternalTimerEventHandler;
fin;

Dans cet exemple, "FTimer" est une variable de champ privé du formulaire ou du conteneur visuel (ou quel que soit "Self"). Lorsque vous accédez à la variable FTimer à partir des méthodes de cette classe, c'est une très bonne idée de vérifier si la référence est valide avant de l'utiliser. Cela se fait à l'aide de la fonction affectée de Delphi:

si assigné (FTimer) alors FTimer.Enabled: = True;

Création dynamique et références d'objets sans propriétaires
Une variante à cela consiste à créer le composant sans propriétaire, mais à conserver la référence pour une destruction ultérieure. Le code de construction du TTimer ressemblerait à ceci:

FTimer: = TTimer.Create (nil);
avec FTimer do
commencer
…
fin;

Et le code de destruction (probablement dans le destructeur du formulaire) ressemblerait à ceci: