CodeS-SourceS
Rechercher un code, un tuto, une réponse

Comment utiliser un formulaire sans avoir besoin de le déclarer dans le uses - tutoriel sur les interfaces et la poo

Avril 2017


Comment se passer d’une référence pour appeler un objet défini dans cette dernière ?


Soit 2 unités, l’une contient un objet et l’autre veut appeler cet objet sans faire de use de la première. Pourquoi ? Imaginez que la première unité contient déjà des dizaines de références à d’autres unités. Le fait d’ajouter l’unité de l’objet obligera obligatoirement d’ajouter soit les chemins d’accès, soit carrément les dites unités à notre projet. Ce qui aura pour effet de gonfler considérablement notre application alors qu’on a besoin que d’une petite partie.

Pour cela 2 méthodes simples peuvent nous servir.

RegisterClass et getClass

Si l’on reprend la définition de l’aide de Delphi, RegisterClass Recense une classe d'objet persistant pour que le type de classe puisse être retrouvée. Et GetClass, Renvoie une classe persistante recensée à partir de son nom de classe.

Grâce à ces 2 méthodes, nous allons pouvoir résoudre notre problème.

L’exemple Delphi fourni va faire appel à cette méthode pour créer un formulaire sans avoir besoin de faire référence à ce dernier. Tout simplement en appelant GetClass (‘ MonFormulaire ’). Dans l’exemple on utilise également une interface pour permettre un partage mémoire de la classe, mais on peut très bien s’en passer. Voici cependant le synopsis du projet.

L’unité intUnit contient l’ensemble des méthodes de partage, chaque fois que l’on veut partager un objet et faire appel à ce dernier dans l’ensemble d’un projet, il suffit de faire un uses sur cette unité et rien d’autre. Cette unité sert donc d’interface car elle doit également être placée dans les autres unités que l’on veut partager.

intUnit contient une interface de partage nommée IInterfacedObject .

/// < summary >
/// interface permettant d'avoir un objet unique en mémoire, qui peut être partagé
/// par plusieurs modules ou applications
/// </ summary >
IInterfacedObject = interface ( IInterface )
[ '{B7CE8FC8-D0AC-49F5-BD74-0BE69FF811EC}' *
// placer ici les méthodes voulant être partagée
procedure ShowForm ;
procedure SendMessage ( const msg : string );
end ;

Cette interface sera notre référence mémoire dans tous les projets pour appeler notre formulaire

intUnit contient également la méthode GetObject pour instancier notre interface

/// < summary >
/// méthode d'appel du formulaire
/// cette méthode est celle à partager dans tous les modules ou l'on souhaite créer sans se lier aux unités
/// < param name =' className : string'>nom de la classe à instancier</ param >
/// </ summary >
function GetObject ( const className : string ): IInterfacedObject ;

Et nous avons enfin, la méthode

/// < summary >
/// méthode permettant d' instancer une classe de n' importequel type
/// < param name =' Aowner : TComponent '>objet parent de la classe à instancier, peut être à NIL</ param >
/// < param name =' InstanceClass : TComponentClass '>
/// < param name =' Reference : non typé'>paramètre de sortie, permettant d'instancier une classe sans avoir besoin de son type</ param >
/// </ summary >
procedure InstancyComponent ( Aowner : TComponent ; InstanceClass : TComponentClass ; var Reference );

Nous avons également une unité uForm2 qui sera notre formulaire parent un TForm interfacé avec IInterfacedObject

TForm2 = class ( TForm , IInterfacedObject )
Memo1: TMemo ;
private
{ Déclarations privées }
public
{ Déclarations publiques }
procedure ShowForm ;
procedure SendMessage (const msg : string);
end ;

2 méthodes test sont donc interface dans ce formulaire, ShowForm et SendMessage , une classe interfacée doit obligatoirement contenir les mé thod es définies dans l’interface.

Nous avons ensuite une unité uForm3 qui hérite elle de uForm2 et donc de toute ces méthodes. C’est elle que l’on va appeler sans ajouter de uses uForm3 dans notre unité d’appel. Pour qu’elle soit connue de l’ensemble du programme, on appel la méthode RegisterClass (TForm3) dans l’initialisation de l’unité uForm3 . Et nous appelons UnRegisterClass (TForm3) dans la finalisation de l’unité dès que l’on quitte le programme.

Enfin dans notre unité principale, uMain , on fait simplement appel à intUnit pour créer TForm3

// vous remarquerez qu'on ne libère pas une interface, le programme s'en charge tout seul
procedure TForm1.Button1Click(Sender: TObject );
begin
// supprimez simplement ce test si vous voulez plusieurs interface, ici, on n'affiche qu'une seule form
if Formulaire= nil then
begin
// je veux par exemple une instance de TForm3 défini e dans uForm3, remarquez qu'on n e fait pas appel à uForm3 dans les uses :)
Formulaire:= GetObject ('TForm3' );
if Formulaire <> nil then // si on a réussie à instancier TForm3 on appel la méthode partagée ShowForm
Formulaire.ShowForm ;
end;
end;

Adresse d'origine

A voir également

Publié par cs_Keneda.
Ce document intitulé «  Comment utiliser un formulaire sans avoir besoin de le déclarer dans le uses - tutoriel sur les interfaces et la poo  » issu de CodeS-SourceS (codes-sources.commentcamarche.net) est mis à disposition sous les termes de la licence Creative Commons. Vous pouvez copier, modifier des copies de cette page, dans les conditions fixées par la licence, tant que cette note apparaît clairement.
Imprimer tout type de document (pdf, doc, xls, html, rtf, docx) par programmation
[delphi] debuguer ou deboguer une application service windows