Les interfaces sous Delphi

Version imprimable

Bonjour

les interfaces sous delphi, quel utilité, comment les utiliser,pourquoi doit on avoir ce type de déclaration ?
Code:

1 2 3 4 5 6 7 type IInterface = interface ['{00000000-0000-0000-C000-000000000046}'] function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall; function _AddRef: Integer; stdcall; function _Release: Integer; stdcall; end;
Après avoir fais un long tour sur les tuts ici et ailleurs j'ai compris que les interfaces sont faites pour l'héritage multiple, sauf je ne vois aucun héritage multiple, car je dois recréer un interface et cette dernière est abstraire d'où je dois réécrire mes procédures déclarées dans l'interface 8O.
Enfin tout n'est pas clair pour moi :cry:.
je compte sur votre aide et vos exemples pour clarifier tout ceux-ci

Merci

Citation:
Envoyé par Jcpan
Bonjour

les interfaces sous delphi, quel utilité, comment les utiliser,pourquoi dois on avoir ce type de déclaration ?
Code:

1 2 3 4 5 6 7 type IInterface = interface ['{00000000-0000-0000-C000-000000000046}'] function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall; function _AddRef: Integer; stdcall; function _Release: Integer; stdcall; end;
Après avoir fais un long tour sur les tuts ici et ailleurs j'ai comprisque les interfaces sont faites pour l'heritage multiple, sauf je ne vois auccun heritage multiple, car je dois recréer un interface et cette dernière est abstraire d'ou je dois réécrire mes procédures déclarées dans l'interface 8O.
Enfin tout n'est pas clair pour moi :cry:.
je compte sur votre aide et vos exemple pour clarifier tout ce ci

Merci
NON ! l'héritage multiple n'existe PAS sous Delphi :)

Les interfaces permettent de regrouper un ensemble de méthodes d'une classe sous une forme définie par ladite interface, c'est tout :)

à quoi ça sert ? c'est simple, prend les Streams sous Delphi, tous les objets flux dérivent de TStream. Il est impossible de faire un "SaveToStream()" vers autrechose qu'un dérivé de TStream...alors qu'on pourrait très bien imaginer un TMemo qui afficherait un dump hexadécimal des données par exemple.

Si on veux faire ça, on va créer un TMemoStream dérivé de TStream qui pointera sur un TMemo qu'il alimentera. Si Delphi supportait l'héritage multiple on pourrait également créer une classe qui dériverait à la fois de TMemo et TStream...mais ça n'est pas possible sous Delphi.

Maintenant, une autre approche serait de ne pas utiliser SaveToStream qui attend un TStream mais SaveToIStream qui attend une interface IStream. Une telle interface ne fait référence à aucune implémentation, mais juste à une liste de méthodes nécessaire au bon fonctionnement du Save. Tout objet qui supporte cette interface, quelque soit ses ancêtres, pourra fonctionner avec cette méthode. On pourra alors créer une classe TMemoStream qui dérive de TMemo et qui implémente l'interface IStream.

D'autre part, les interfaces subissent un traitement particulier de la part de Delphi. A chaque fois qu'on fait référence à une interface, Delphi invoque automatiquement sa méthode _AddRef, et à chaque fois qu'une variable de type interface sort de la portée (une variable locale en fin de procédure, une variable interne à un objet détruit...ou encore une interface à laquelle on affecte "nil") c'est la méthode _Release qui est invoquée.

Si l'interface est une classe Delphi dérivée de TInterfacedObject et uniquement dans ce cas, l'objet est automatique détruit car TInterfacedObject invoque son destructor quand le compteur de référence tombe à zéro...dans tous les autres cas, cela dépendra de l'implementation qui est faite de _AddRef et _Release :)

25/11/2008, 11h08
Jcpan

pouvez vous rediger un exemple une exemple SVP :cry::bug:

Citation:

Envoyé par Jcpan

pouvez vous rediger un exemple une exemple SVP :cry::bug:

voici deux approches différents d'un même problème, l'une par héritage, l'autre par interfaces :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
type
 TFruit=class
  procedure Mange; virtual;
 end;
 TPomme=class(TFruit)
  procedure Mange; override;
 end;
 TRaisin=class(TFruit)
  procedure Mange; override;
 end;
 
procedure TPomme.Mange;
begin
 ShowMessage('Croc');
end;
 
procedure TRaisin.Mange;
begin
 ShowMessage('Splitch');
end;
 
procedure Manger(Fruit:TFruit);
begin
  Fruit.Mange;
end;

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
type
 IMangeable=Interface
  procedure Mange; 
 end;
 
 TFruit=TInterfacedObject
 end;
 
 TPomme=class(TFruit, IMangeable)
  procedure Mange; 
 end;
 
 TRaisin=class(TFruit, IMangeable)
  procedure Mange; 
 end;
 
 TVoiture=class(TInterfacedObject, IMangeable)
  procedure Mange; 
 end;
 
procedure TPomme.Mange;
begin
 ShowMessage('Croc');
end;
 
procedure TRaisin.Mange;
begin
 ShowMessage('Splitch');
end;
 
procedure TVoiture.Mange;
begin
  ShowMessage('Pas bon !');
end;
 
procedure Manger(Mangeable:IMangeable);
begin
  Mangeable.Mange;
end;

25/11/2008, 11h34
Jcpan
Merci :D
la procedure Mange doit etre abstraite, exact ?
Code:

1 2 3 type TFruit=class procedure Mange; virtual;abstract;
25/11/2008, 13h29
Paul TOTH
Citation:
Envoyé par Jcpan

Merci :D
la procedure Mange doit etre abstraite, exact ?

Code:

1 2 3 type TFruit=class procedure Mange; virtual;abstract;
éventuellement...mais elle pourrait aussi répondre par défaut "hummm...c'est bon" :)

NB: la méthode Mange pourrait être virtuelle également dans le deuxième exemple, mais elle n'a pas besoin d'être héritée d'un ancêtre commun. Il suffit que chaque classe qui implémente IMangeable en possède une, que ce soit par héritage ou pas.

je sais que je suis gourmand mais désolé je pose encore une question

qu'en est-il de

Code:

1
2
3
4
    ['{00000000-0000-0000-C000-000000000046}']
    function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;
    function _AddRef: Integer; stdcall;
    function _Release: Integer; stdcall;

Citation:
Envoyé par Jcpan
je sais que je suis gourmand mais désolé je pose encore une question

qu'en est-il de
Code:

1 2 3 4 ['{00000000-0000-0000-C000-000000000046}'] function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall; function _AddRef: Integer; stdcall; function _Release: Integer; stdcall;
toute interface implémente au moins ces trois fonctions, voila tout :)

QueryInterface qui permet de savoir si un objet implémente une interface donnée (sous Delphi c'est invoqué automatique avec l'opérateur "as").
Code:

1 2 3 4 5 6 7 8 var v:TVoiture; m:IMangeable; begin v := TVoiture.Create; m := v as IMangeable; end;
AddRef et Release sont expliqués plus haut...si Delphi ne le faisait pas tout seule il faudrait invoquer AddRef quand on veux utiliser une interface et Release quand on en a plus besoin (libre à l'objet qui implémente ces méthodes d'en faire ce qu'il veux...)

27/11/2008, 11h18
Jcpan

Citation:

Envoyé par Paul TOTH

D'autre part, les interfaces subissent un traitement particulier de la part de Delphi. A chaque fois qu'on fait référence à une interface, Delphi invoque automatiquement sa méthode _AddRef,

_Addref incremente le Guid ?
27/11/2008, 14h04
Aka Guymelef

Non pas du tout.

Le guid est là pour donner un identifiant unique à ton interface. C'est très important notamment si ton interface s'utilise pour du COM.

AddRef et Release ne font que, respectivement, incrémenter et décrémenter un compteur (de référence) interne. Lorsque le compteur de référence tombe à 0, Delphi détruit l'instance de l'objet qui implémente ton interface.
28/11/2008, 10h44
Paul TOTH

Citation:

Envoyé par Aka Guymelef

Non pas du tout.

Le guid est là pour donner un identifiant unique à ton interface. C'est très important notamment si ton interface s'utilise pour du COM.

AddRef et Release ne font que, respectivement, incrémenter et décrémenter un compteur (de référence) interne. Lorsque le compteur de référence tombe à 0, Delphi détruit l'instance de l'objet qui implémente ton interface.

en effet, le GUID n'est qu'un IDentifiant Global Unique qui permet d'identifier une interface donnée (voir QueryInterface d'ailleurs à ce sujet).

Pour ce qui est de l'implémentation faite de AddRef et Release...je dirais que la libération lorsque le compteur tombe à zéro est probablement le comportement attendu...mais cela reste à la discrétion du développeur. Mais c'est en effet le cas de TInterfaceObject :)