Définition et implémentation d'interfaces dans Delphi

Dans Delphes, "interface" a deux significations distinctes. Dans OOP jargon, vous pouvez considérer une interface comme une classe sans implémentation. Dans Delphi, la section d'interface de définition d'unité est utilisée pour déclarer toutes les sections publiques de code qui apparaissent dans une unité. Cet article expliquera les interfaces d'un point de vue POO.

Si vous êtes prêt à créer une application solide comme une manière que votre code soit maintenable, réutilisable et flexible, le OOP La nature de Delphi vous aidera à conduire les premiers 70% de votre itinéraire. Définir des interfaces et les implémenter aidera avec les 30% restants.

Vous pouvez considérer une interface comme une classe abstraite avec toute l'implémentation supprimée et tout ce qui n'est pas public supprimé. Une classe abstraite Delphes est une classe qui ne peut pas être instanciée - vous ne pouvez pas créer un objet à partir d'une classe marquée comme abstraite.

Jetons un coup d'œil à un exemple de déclaration d'interface:

type
IConfigChanged = interface['{0D57624C-CDDE-458B-A36C-436AE465B477}']
procédure ApplyConfigChange;
fin;

le IConfigChanged est une interface. Une interface est définie un peu comme une classe, le mot clé "interface" est utilisé à la place de "classe". La valeur Guid qui suit le mot clé interface est utilisée par le compilateur pour identifier l'interface de manière unique. Pour générer une nouvelle valeur GUID, appuyez simplement sur Ctrl + Maj + G dans l'IDE Delphi. Chaque interface que vous définissez a besoin d'une valeur Guid unique.

Une interface en POO définit une abstraction - un modèle pour une classe réelle qui implémentera l'interface - qui implémentera les méthodes définies par l'interface. Une interface ne fait rien, elle a seulement une signature pour l'interaction avec d'autres classes (ou implémentations) ou interfaces.

L'implémentation des méthodes (fonctions, procédures et méthodes Get / Set de propriété) se fait dans la classe qui implémente l'interface. Dans la définition de l'interface, il n'y a pas de sections de portée (privées, publiques, publiées, etc.) tout est public. Un type d'interface peut définir des fonctions, des procédures (qui deviendront éventuellement des méthodes de la classe qui implémente l'interface) et des propriétés. Lorsqu'une interface définit une propriété, elle doit définir les méthodes get / set - les interfaces ne peuvent pas définir de variables.

Comme pour les classes, une interface peut hériter d'autres interfaces.

type
IConfigChangedMore = interface(IConfigChanged)
procédure ApplyMoreChanges;
fin;

La plupart des développeurs Delphi, lorsqu'ils pensent aux interfaces, pensent à la programmation COM. Cependant, les interfaces ne sont qu'une fonctionnalité de POO du langage - elles ne sont pas liées spécifiquement à COM. Les interfaces peuvent être définies et implémentées dans une application Delphi sans toucher du tout à COM.

Pour implémenter une interface, vous devez ajouter le nom de l'interface à l'instruction de classe, comme dans:

type
TMainForm = classe(TForm, IConfigChanged)
Publique
procédure ApplyConfigChange;
fin;

Dans le code ci-dessus, un formulaire Delphi nommé "MainForm" implémente l'interface IConfigChanged.

avertissement: lorsqu'une classe implémente une interface, elle doit implémenter toutes ses méthodes et propriétés. Si vous échouez / oubliez d'implémenter une méthode (par exemple: ApplyConfigChange) une erreur de temps de compilation "E2003 Identificateur non déclaré: 'ApplyConfigChange'" se produira.
avertissement: si vous essayez de spécifier l'interface sans la valeur GUID, vous recevrez: "E2086 Le type 'IConfigChanged' n'est pas encore complètement défini".

Considérons une application MDI où plusieurs formulaires peuvent être affichés à l'utilisateur en même temps. Lorsque l'utilisateur modifie la configuration de l'application, la plupart des formulaires doivent mettre à jour leur affichage: afficher / masquer certains boutons, mettre à jour les légendes des étiquettes, etc. Vous auriez besoin d'un moyen simple d'aviser tous les formulaires ouverts qu'un changement dans la configuration de l'application s'est produit. L'outil idéal pour le travail était une interface.

Chaque formulaire qui doit être mis à jour lorsque les modifications de configuration implémenteront IConfigChanged. Étant donné que l'écran de configuration s'affiche de manière modale, lorsqu'il se ferme, le code suivant garantit que tous les formulaires d'implémentation IConfigChanged sont notifiés et que ApplyConfigChange est appelé:

procédure DoConfigChange ();
var
cnt: entier;
icc: IConfigChanged;
commencer
pour cnt: = 0 à -1 + écran. FormCount faire
commencer
si Supports (écran. Formulaires [cnt], IConfigChanged, icc) ensuite
icc. ApplyConfigChange;
fin;
fin;

Les soutiens une fonction (défini dans Sysutils.pas) indique si un objet ou une interface donné prend en charge une interface spécifiée. Le code parcourt l'écran. Collection de formulaires (de l'objet TScreen): tous les formulaires actuellement affichés dans l'application. Si un formulaire Écran. Formulaires [cnt] prend en charge l'interface, Supports renvoie l'interface pour le dernier paramètre paramètre et renvoie true.

Par conséquent, si le formulaire implémente IConfigChanged, la variable icc peut être utilisée pour appeler les méthodes de l'interface mises en œuvre par le formulaire. Notez bien sûr que chaque formulaire peut avoir sa propre implémentation différente de la procédure ApplyConfigChange.

Toute classe que vous définissez dans Delphi doit avoir un ancêtre. TObject est l'ancêtre ultime de tous les objets et composants. L'idée ci-dessus s'applique également aux interfaces, l'IInterface est la classe de base pour toutes les interfaces. IInterface définit 3 méthodes: QueryInterface, _AddRef et _Release.

Cela signifie que notre IConfigChanged possède également ces 3 méthodes, mais nous ne les avons pas implémentées. C'est parce que TForm hérite de TComponent qui implémente déjà l'IInterface pour vous! Lorsque vous souhaitez implémenter une interface dans une classe qui hérite de TObject, assurez-vous que votre classe hérite de TInterfacedObject à la place. Puisque TInterfacedObject est un TObject implémentant IInterface. Par exemple:

TMyClass = classe(TInterfacedObject, IConfigChanged)
procédure ApplyConfigChange;
fin;

En conclusion, IUnknown = IInterface. IUnknown est pour COM.