Les références de classe ou métaclasses

Une classe (un type classe) définit une structure composée de champs, de méthodes et de propriétés. Les champs, méthodes et propriétés d'une classe sont appelés ses composants ou ses membres.

type NomDeClasse = class (ClasseAncêtre)
  ListeMembre
 end;

Détails sur la déclaration de classes

Une méthode est une procédure ou une fonction associée à une classe.

Les objets sont des blocs de mémoire alloués dynamiquement dont la structure est déterminée par leur type de classe. Chaque objet détient une copie unique de chaque champ défini dans la classe. Par contre, toutes les instances d'une classe partagent les mêmes méthodes. Les instances d'un type classe, c'est-à-dire les instances de classe, sont appelées des objets.

Une variable de type classe est en fait un pointeur qui référence le bloc mémoire alloué pour un objet. Plusieurs variables peuvent donc désigner le même objet. Comme les autres pointeurs, les variables de type classe peuvent contenir la valeur nil, dans ce cas elle ne fait donc aucune référence à un objet.

Une variable de type TObject contient une instance de la classe TObject.

Note : Un constructeur renvoie une référence d'objet.

C'est la classe des exceptions pour les appels de méthodes abstraites, déclarée dans l'unité sysutils.pas

...
EAbstractError = class(Exception);
...

EAbstractError est déclenchée quand une application tente d'appeler une méthode abstraite. Elle est également déclenchée à la conception quand un composant contenant une méthode abstraite est placé sur une fiche.

Cette gestion est interne à Delphi. Nous ne pourrons donc la manipuler que dans un bloc d'exception.
Le code suivant est compilé sans warning, car aucune des méthodes utilisées n'est abstraite, mais provoquera une exception à l'exécution :

var Liste:TStrings;
    Chaine:String;
begin
  Try
   Liste:=TStrings.Create;
   Try
     // La méthode Add appelle la méthode abstraite GetCount
    Liste.Add('Une chaine');
   Except
   On EAbstractError do
    MessageDlg('Vous devez implémenter la méthode GetCount', mtError, [mbOK], 0);
   End ;
  Finally
   Liste.Free;
  end;
end;

Vous pouvez créer une instance de classe possédant une méthode abstraite dans ce cas le compilateur vous avertira par le message :

175. Construction d'instance de '<...>' contenant des méthodes abstraites.

La seule chose à respecter est de ne pas appeler la ou les méthodes abstraites directement ou indirectement.

Détails sur la déclaration Abstract

Une valeur de type référence de classe est compatible en terme d'affectation avec tout type référence de classe ancêtre.

Extrait de l'unité Classes de la VCL :

…
{ TComponent class reference type }

  TComponentClass = class of TComponent;
…
  TComponent = class(TPersistent)
  Private
   // Déclaration complète de la classe
…
  TControl = class(TComponent)
  Private
   // Déclaration complète de la classe
…
  TControlClass = class of TControl;

Par exemple pour les variables suivantes ces affectations sont valides :

Var
 ComponentClass : TComponentClass ;
 ControlClass   : TControlClass

Begin
 ComponentClass := TComponent ; // Valide
 ComponentClass := TControl; // Valide
...

Alors que dans ces affectations seules la seconde est valide :

Var
 ComponentClass : TComponentClass ;
 ControlClass   : TControlClass

Begin
 ControlClass := TComponent ; // Invalide
 ControlClass := TControl; // Valide

La première est invalide, car la classe TComponent n'est pas une classe descendante de TControl et n'est donc pas une valeur de type TControlClass.

De même lors d'une vérification de type on doit vérifier des classes descendantes vers les classes ancêtre, car une instance de la classe descendante est aussi une instance de la classe ancêtre.

Si on souhaite connaître la classe exacte d'une instance de classe afin d'effectuer un traitement particulier :

if Instance is TControl
 then …
 else
 if Instance is TComponent
   then …
   else
    if Instance is TPersistent
     then …
     else
      if Instance is TObject
       then …

ControlClass   := Nil;
if ControlClass = Nil
   then Exit;

En fait, c'est par l'utilisation des références de classe et des constructeurs virtuels que le concepteur de forme de Delphi peut créer les composants qui sont placés sur des fiches.

Pour des explications plus détaillées, je vous renvoie vers les cours suivant au lieu de réécrire ce qui a été déjà très bien dit, nous appliquerons donc le principe de la réutilisation :-)

Cours sur les constructeurs virtuels
Héritage et notions évoluées

Quand il est appelé via un identificateur de type classe ( TEdit.Create ), un constructeur déclaré comme virtuel est équivalent à un constructeur statique. Par contre, quand ils sont combinés avec des types référence de classe ( ReferenceClass.Create ), les constructeurs virtuels permettent une construction polymorphique des objets : c'est-à-dire la construction d'objets dont le type est inconnu à la compilation.

Par exemple dans le code qui suit la variable Reference est une référence de classe pour la classe TClasseDeBase. Par conséquent, toutes les classes dérivées de TClasseDeBase peuvent être assignées à Reference.

TClasseDeBase = class( TObject )
    Numero: Byte;
    constructor Create; { Constructeur statique }
  end;

  TClasseDescendante = class( TClasseDeBase )
     constructor Create; { Constructeur statique }
  end;

  TExemple = class( TClasseDeBase )
    constructor Create; { Constructeur statique}
  end;

  TClassDeClasseDeBase = class of TClasseDeBase;  { Référence de classe }

var
  Form1: TForm1;

  Reference : TClassDeClasseDeBase;       { Variable référence de classe }
  Instance  : TClasseDeBase;              { Variable d'instance de classe }

Le code de cet exemple

Afin de visualiser le comportement entre un constructeur statique et un constructeur virtuel ce code est volontairement erroné, bien que sa syntaxe soit correcte.

Exécutez ce programme et créez un objet de chaque classe.

Dans cet exemple tout fonctionne correctement en dehors du fait que le contenu de la variable Numero ne correspond pas à ce que nous attendons. C'est-à-dire que les données spécifiques aux classes descendantes ne sont pas initialisées.

Instance  := Reference.Create;
 Memo1.Lines.Add('Création d''une instance de la classe '+Instance.Classname);

Le code précédant crée bien une instance de la classe voulue, mais le constructeur appelé est toujours celui de la classe ancêtre. À noter que si nous déclarons une méthode virtuelle dans chacune de ces classes, la méthode de la classe réelle est bien appelée.

Modifions les déclarations de classe comme ceci :

TClasseDeBase = class( TObject )
    Numero: Byte;
    constructor Create; Virtual;   { Constructeur Virtuel }
  end;

  TClasseDescendante = class( TClasseDeBase )
     constructor Create; override; { Constructeur surchargé }
  end;

  TExemple = class( TClasseDeBase )
    constructor Create; override;  { Constructeur surchargé }
  end;

Le code modifié

L'ajout de la directive Virtual ou override pour les classes descendantes permet bien d'appeler le constructeur de la classe référencée et non pas celui de la classe ancêtre.

Polymorphe
«  Qui peut se présenter sous des formes différentes. »

Polymorphisme ou polymorphie
«  Caractère de ce qui est polymorphe. »

Nous avons pu voir que la référence de classe associée au constructeur virtuel permet l'implémentation du polymorphisme, c'est-à-dire permettre à une instance d'avoir plusieurs formes ou plutôt plusieurs comportements.

La référence d'objet utilisée se présentera à un moment t sous une seule forme, mais se comportera de manière différente tout au long de l'exécution du programme.

À noter qu'il ne faut pas confondre le polymorphisme avec l'héritage multiple, voir aussi le pattern Wrapper. C'est-à-dire permettre à un objet de se présenter sous une seule forme tout au long de son existence, mais pouvant se comporter de différente manière.

Détails sur le polymorphisme

https://rmdiscala.developpez.com/cours/livres/basesinfo5.3.pdf

Guide Pascal et Delphi - Polymorphisme

Nous souhaitons lors de l'exécution du programme créer une instance de TControl parmi les trois classes descendantes suivantes : TEdit,TButton,TMemo.

La classe que nous souhaitons instancier est donc inconnue au moment de la compilation. Nous utiliserons la référence de classe TControlClass déclarée dans l'unité classes qui nous permettra de manipuler les trois classes citées.

Nous utiliserons une seule variable référence de classe pouvant être tour à tour soit un TEdit, soit un TButton, soit un TMemo.

VI-D-1. Gestion des trois classes souhaitées▲

Cet exemple implémente de manière simple le polymorphisme, ici ce qui va différencier chaque control c'est la manière dont il s'affiche à l'écran. Le control se comportera différemment selon sa classe réelle à l'exécution. Il existe bien sûr d'autres différences, mais l'affichage étant la plus 'remarquable'.

L'interface de notre programme permettra donc de créer une instance parmi ces trois classes.

Le bouton Créer utilisera une méthode regroupant la sélection de la classe puis la création de l'instance.

Le bouton Fabriquer utilisera une méthode dédiée à la création d'instance de classe TControlClass.

Première version du code

Exécutez le programme et créez une instance de chaque classe.

 

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

procedure TForm1.Creer;
Begin
  FreeAndNil(Instance);
  case rgClasseObjet.ItemIndex of
    0 : ControlClass:=TEdit;
    1 : ControlClass:=TButton;
    2 : ControlClass:=TMemo;
  end;
                                                         // Appel la méthode de classe
  MemoLog.Lines.Add('Création d''une instance de la classe '+ControlClass.ClassName);
  // provoque une erreur lors de la compilation :
  // MemoLog.Lines.Add('Création d''une instance de classe '+ControlClass.ClassType);

  Instance :=ControlClass.Create(Self );
  Instance.Parent:=Panel1;
end;

La ligne 3 permet de supprimer l'instance précédemment créée.

Les lignes 5, 6, 7 affectent à la variable référence de classe ControlClass le type de classe que l'on souhaite instancier.

La ligne 10 appelle la méthode de classe (que nous aborderons un peu plus tard) Classname afin d'afficher le type de la classe sélectionnée.

La ligne 12 nous démontre qu'une variable référence de classe ne peut pas effectuer d'appel sur des méthodes autres que des méthodes de classes.

Le compilateur renvoie :

 

Sélectionnez

77. Forme d'appel de méthode autorisée seulement pour méthodes de classe

La ligne 14 crée une instance de classe via l'appel du constructeur virtuel de la classe référencée dans la variable ControlClass. Les classes TEdit,TButton,TMemo possèdent toutes un constructeur Virtuel.

Et enfin la ligne 15 renseigne le parent du control créé permettant de l'afficher dans le panel placé à droite dans la fenêtre principale.

La fonction suivante est appelée via le code associé au bouton Fabriquer :

 

Sélectionnez

function TForm1.FabriqueUnControl(Reference : TControlClass; MonParent : TWinControl): TControl;
begin
 MemoLog.Lines.Add('Création d''une instance de la classe '+Reference.ClassName);

 Result:=Reference.Create(Self); // Propriétaire :  Il contrôle quand le composant est libéré
 Result.Parent:=MonParent;        // Parent : C'est le contrôle fenêtré contenant le contrôle créé
end;

On retrouve donc tous les acteurs de la procédure Créer, mais ici on généralise l'utilisation du traitement de création d'instance. L'ajout du propriétaire du control (self) dans la liste des paramètres permettrait d'isoler cette fonction dans une unité.

Un autre exemple d'utilisation de type référence de classe est fourni par la déclaration du constructeur de TCollection, extrait de l'unité Classes de la VCL :

 

Sélectionnez

type TCollectionItemClass = class of TCollectionItem;
  ...
constructor Create(ItemClass: TCollectionItemClass);

Cette déclaration indique que pour créer un objet instance de TCollection, il faut transmettre au constructeur le nom d'une classe descendant de TCollectionItem.

VI-D-2. Ajout de la classe TObject▲

...
procedure TForm1.Creer;
Begin
 FreeAndNil(Instance);
 case rgClasseObjet.ItemIndex of
   0 : ControlClass:=TEdit;
   1 : ControlClass:=TButton;
   2 : ControlClass:=TMemo;
   3 : ControlClass:=TObject;
 end;
...
procedure TForm1.Fabriquer;
Begin
 FreeAndNil(Instance);
 case rgClasseObjet.ItemIndex of
   0 : Instance:=FabriqueUnControl(TEdit,Panel1);
   1 : Instance:=FabriqueUnControl(TButton,Panel1);
   2 : Instance:=FabriqueUnControl(TMemo,Panel1);
   3 : Instance:=FabriqueUnControl(TObject,Panel1);
 end;
end;
...

Types incompatibles : '<TControlClass>' et '<Class Reference>'

3 : ControlClass:=TControlClass(TObject);

3 : Instance:=FabriqueUnControl(TControlClass(TObject),Panel1);

procedure TForm1.Creer;
Begin
 FreeAndNil(Instance);
 case rgClasseObjet.ItemIndex of
   0 : ControlClass:=TEdit;
   1 : ControlClass:=TButton;
   2 : ControlClass:=TMemo;
   3 : ControlClass:=TControlClass(TObject);
 end;
                                                       // Appel la méthode de classe
 MemoLog.Lines.Add('Création d''une instance de la classe '+ControlClass.ClassName);
 Try
  Instance :=ControlClass.Create(Self );
  Instance.Parent:=Panel1;
 Except
  On E:EAccessViolation do
   MessageDlg('La méthode create n''est pas adaptée pour la classe '+ControlClass.ClassName, mtError, [mbOK], 0);
 end;
end;

Try
  Instance :=ControlClass.Create(Self );
  Instance.Parent:=Panel1;
 Except
  On E:EAccessViolation do
   Instance :=ControlClass.Create;
 end;

If ControlClass is TEdit
  then ...

If ControlClass=TObject
  then ...
Le code suivant est aussi possible : 

var ControlClass : TControlClass;
    ObjetClass     : TClass;

begin
 ControlClass:=TEdit;
 ObjetClass:= TPersistent;
 
 If ControlClass=ObjetClass
  then ...
mais pas celui-ci 

If ControlClass=TClass
  then ...

TObject.InheritsFrom

Détermine la relation entre deux types d'objets.

class function InheritsFrom(AClass: TClass): Boolean;

Description
  Utilisez la méthode InheritsFrom pour déterminer si un type de classe donné est l'ancêtre d'un objet.
  InheritsFrom renvoie True si le type d'objet spécifié par le paramètre AClass est bien l'ancêtre du type de l'objet, 
  ou le type même de l'objet. Sinon, elle renvoie False.

Remarque :
  Les opérateurs is et as utilisent dans leur implémentation la méthode InheritsFrom. Cependant, l'opérateur is ne peut 
  déterminer la relation d'héritage que pour une instance. Alors que InheritsFrom, comme méthode de classe, est capable 
  de déterminer la relation entre des références de classe.

procedure TForm1.Creer;
Begin
 FreeAndNil(Instance);
 case rgClasseObjet.ItemIndex of
   0 : ControlClass:=TEdit;
   1 : ControlClass:=TButton;
   2 : ControlClass:=TMemo;
   3 : ControlClass:=TControlClass(TObject);
 end;
                                                       // Appel la méthode de classe
 MemoLog.Lines.Add('Création d''une instance de la classe '+ControlClass.ClassName);

 If ControlClass.InheritsFrom(TControl)
  then
    begin
     Instance :=ControlClass.Create(Self );
     Instance.Parent:=Panel1;
    end
  else Instance :=ControlClass.Create;
end;

...
  else TObject(Instance) :=TObject(ControlClass).Create;
end;

...
  else TObject(Instance) :=TClass(ControlClass).Create;
end;

// Identificateur de type référence de classe
type TClass = class of TObject;

  // Identificateur de type classe
type TPersistent = class(TObject);

ControlClass:=TControlClass(Sender.ClassType);

VI-D-3. Ajout d'une classe ascendante▲

procedure TForm1.Creer;
Begin
 FreeAndNil(Instance);
 case rgClasseObjet.ItemIndex of
   0 : ControlClass:=TEdit;
   1 : ControlClass:=TButton;
   2 : ControlClass:=TMemo;
   3 : ControlClass:=TControlClass(TObject);
   4 : ControlClass:=TControlClass(TComponent);
 end;
                                                       // Appel la méthode de classe
 MemoLog.Lines.Add('Création d''une instance de la classe '+ControlClass.ClassName);

      // Vérification d'appartenance à une Hiérarchie de classe
 If ControlClass.InheritsFrom(TControl)
  then
    begin
     Instance:=ControlClass.Create(Self );
       // Vérification d'appartenance à une classe
     If ControlClass=TComponent
          // TComponent ne posséde pas de propriétés Parent
      then Exit;
     Instance.Parent:=Panel1;
    end
  else TObject(Instance):=TClass(ControlClass).Create;
end;

ResItem := GetResourceClass(FResType).CreateItem(Self, DirEntry);

Un Singleton prend en charge la création d'une instance de classe et s'assure qu'il n'existera qu'une et seule instance tout au long de l'exécution d'un programme.

L'implémentation de ce pattern est un bon exemple d'utilisation des méthodes de classe.

Vous trouverez sur le site de Borland US un exemple d'implémentation du pattern Singleton.

Delphi ne propose pas en dehors de la méthode GetClass la possibilité d'obtenir une classe à partir d'un nom de classe contenue dans une chaine de caractères pour l'assigner à une référence de classe :

TControlClass=TEdit.Text; // Invalide

L'utilisation de la méthode GetClass permet de récupérer une classe à partir d'un nom de classe :

TControlClass=GetClass(TEdit.Text);

Par contre la classe doit être recensée par RegisterClass pour que la méthode GetClass puisse la trouver. Il faut donc que les classes recensées dérivent de la classe TPersistent.

Et dans le cas suivant :

UneClasse(GetClass(TEdit.Text)).Traitement(params)

il faut que :

• Traitement soit une méthode de classe. Sinon il n'est pas possible d'effectuer l'appel de méthode de cet exemple ;
• Traitement soit une méthode virtuelle ou dynamique. Sinon on risque de perdre l'héritage et donc de ne pas appeler la bonne méthode en fonction de la classe réelle.

La solution suivante proposée par Bloon implémente un mécanisme d'enregistrement pour toutes les classes.
Dans un premier temps nous pourrions utiliser la classe TClassList, mais la classe TStringList a les avantages suivants :

• si vous utilisez un nombre important de classes, la propriété Sorted permet d'accélérer la recherche ;
• la persistance, c'est-à-dire la possibilité d'enregistrer cette liste sur disque.

Pour enregistrer le nom d'une classe et son type :

Var mesClasses :TStringList;
begin
 ...
  // Enregistre le nom de la classe et le type de la classe, mais pas l'objet
 mesClasses.AddObject('TMaClasse',TObject(TMaClasse));
 ...

Pour retrouver une classe par son nom :

Var mesClasses : TStringList;
    MaClasse   : TControlClass;
    i            : Integer;

begin
  ...
         // Recherche dans la liste d'association
  i := mesClasses.IndexOf('TEdit');

  if (i = -1)
          // si pas trouvé, on renvoie nil
   then MaClasse := nil;
         // si trouvé, on renvoie la classe associée
   else MaClasse:= TClass(mesClasses.objects[i]);
  ...

En utilisant les méthodes de classe, il est également possible de faire :

procedure addClass(UneClasse : TClass);
begin
  mesClasses.AddObject(UneClasse.ClassName,TObject(UneClasse));
end;

Exemple :

type
 TRefMesClasses = class of TMesClasses;
var
  classByName : TStringList;

// Enregistrer une classe
procedure registerClassByName(classe: TRefMesClasses);
begin
  // Ajout de la classe si elle n'est pas déjà référencée
  if (classByName.IndexOf(classe.ClassName) = -1) then
  begin
    classByName.AddObject(classe.ClassName,TObject(classe));
  end;
end;

// Obtenir une classe par son nom
function getClassByName(nom: string): TRefMesClasses;
var
  i : integer;
begin
  // Recherche dans la liste des classByName
  i := classByName.IndexOf(nom);
  // si pas trouvé, on renvoie nil
  if (i = -1) then
  begin
    result := nil;
  end
  // si trouvé, on renvoie la classe associée
  else
  begin
    result := TRefMesClasses(classByName.objects[i]);
  end
end;

// Au début de l'application, enregistrer les classes  :
classByName := TStringList.Create;
registerClassByName(MaClasse1);
...
// Fin d'application, libérer classByName
classByName.Free;
// Utilisation :
getClassByName(Edit1.Text).Traitement...

Cette approche générique nous permet d'améliorer le premier code source présenté dans le chapitre «  les références de classe ou métaclasses » : Donc à la place de :

...
 case rgClasseObjet.ItemIndex of
   0 : ControlClass:=TEdit;
   1 : ControlClass:=TButton;
   2 : ControlClass:=TMemo;
   3 : ControlClass:=TControlClass(TObject);
 end;
 MemoLog.Lines.Add('Création d''une instance de la classe '+ControlClass.ClassName);

 Instance :=ControlClass.Create(Self );
 Instance.Parent:=Panel1;

on écrira :

procedure TForm1.Creer;
Begin
 if (rgClasseObjet.ItemIndex <= -1)
  then Exit;

 FreeAndNil(Instance);

 with rgClasseObjet do
   // Appel la méthode de classe
  Instance := TControlClass(Items.Objects[ItemIndex]).Create(Self);
 Instance.Parent:=Panel1;

 MemoLog.Lines.Add('Création d''une instance de la classe '+Instance.ClassName);
end;

La méthode FormCreate devenant :

procedure TForm1.FormCreate(Sender: TObject);
begin
 ControlClass :=Nil;
 Instance :=Nil;
 rgClasseObjet.Items.AddObject('TEdit',TObject(TEdit));
 rgClasseObjet.Items.AddObject('TButton',TObject(TButton));
 rgClasseObjet.Items.AddObject('TMemo',TObject(TMemo));
end;

Code source modifié.