Discussion :

[Papy214]

Bonjour

C'est peut-être évident mais je cale.

J'ai une dll avec plusieurs interfaces.
Pour chacune de ces interfaces j'ai une procédure spécifique qui utilise un callback pour renvoyer un type d'interface à la fois.

J'aimerais rajouter une procedure qui renvoie n'importe quelle de ces interfaces et que le programme appelant puisse définir de quelle interface il s'agit. Un genre de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
if InterfaceRecue is IInterface1 then ...
 
else if InterfaceRecue is IInterface25 then ...
 
etc.

Sauf que que le is ne passe pas pour une interface.

Possible ou pas ?

[tourlourou]

Ceci devrait le permettre : if Supports(InterfaceRecue, IInterface1) then et même de récupérer l'interface, avec le risque exposé dans le warning

[ShaiLeTroll]

Ecrit sur le forum, j'ai pas Delphi sous la main, donc c'est plein de faute
J'ai beaucoup joué en C++Builder sur les interfaces entre plusieurs DLL, peu en Delphi
Un peu de lecture [C++\Delphi] Interface, Héritage et Supports !
Cependant même si j'ai eu plus de 100 interfaces (comme évoquée ici), je n'ai jamais eu besoin de faire un "case of", chaque interface était associé à une fonctionnalité logicielle d'un hardware, donc beaucoup de Supports pour savoir ce qui était possible ou pas pour tel ou tel périphérique.

Etudie le code de FMX.Platform.TPlatformServices.SupportsPlatformService
C'est plein d'interface, il y a peut-être des choses qui pourraient t'intéresser pour sur comment utiliser les interfaces au mieux, c'est pour FMX mais je parle surtout de la façon de coder qui reste un concept POO valable pour autre chose.



Tu devrais faire une pattern strategie avec un TCallBack = procedure(AInterface: IInterface);

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
type
  TInterfaceCallBackRegistry = class(TDictionay<TGUID, TCallBack>)
  public
    procedure CallBack(AInterface: IInterface);
    function IsRegisteredGUID(AInterface: IInterface; out AGUID: TGUID): Boolean;
  end;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Registry := TInterfaceCallBackRegistry.Create();

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
procedure TInterfaceCallBackRegistry.CallBack(AInterface: IInterface);
var
  it: TPair<TGUID, TCallBack>;
  intf: IInterface;
begin
  for it in Self do
  begin
    if Supports(AInterface, it.Key, intf) then
   begin
     it.Value(intf);
     Exit;
   end;
  end;
end;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
const
   IID_IInterface1 = '{00000001-0001-0001-0001-000000000001}'
type
  IInterface = interface
    [IID_IInterface1] // si la constante passe pas ['{00000001-0001-0001-0001-000000000001}']
    procedure Truc;
    // ...
  end;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
const
   IID_IInterface25 = '{00000025-0025-0000-0025-000000000025}'
type
  IInterface25 = interface
    [IID_IInterface25] // si la constante passe pas ['{00000025-0025-0000-0025-000000000025}']
    procedure Machin;
    // ...
  end;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Registry.Add( StringToGUID(IID_IInterface1), MonCodePour1); // IID_IInterface1 une constante chaine TGUID, celui associé, faudra peut-être mettre @MonCodePour1 
Registry.Add( StringToGUID(IID_IInterface25), MonCodePour25);

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
procedure MonCodePour1(AInterface: IInterface);
begin
end;
 
procedure MonCodePour25(AInterface: IInterface);
begin
end;

Et ton if if if devient :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Registry.CallBack(InterfaceRecue)

;



tu peux aussi profiter des astuces de compilateur Delphi

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
var
  LGUID: TGUID;
begin
  GUID := IInterface;
  ShowMessage(GUIDToString(LGUID));

la Conversion tu type IInterface vers TGUID est implicite, cependant, je ne sais plus si cela fonctionne avec un référence d'interface, à TESTER !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
function  TInterfaceCallBackRegistry.IsRegisteredGUID(AInterface: IInterface; out AGUID: TGUID): Boolean;
begin
  AGUID := AInterface; // c'est référence d'interface IInterface et non le type IInterface, je ne sais pas si l'astuce fonctionne dans ce cas.
  Result := Self.ContainsKey(AGUID);
end;

[Papy214]

Ceci devrait le permettre : if Supports(InterfaceRecue, IInterface1) then et même de récupérer l'interface, avec le risque exposé dans le warning

Merci ! Je ne connaissais pas Supports. Je cherchais quelque chose comme implement().
ça va bien m'aider dans un premier temps.

[Papy214]

@@ShaiLeTroll

J'aime beaucoup ta méthode. Je n'ai pas une centaine d'interface mais une bonne trentaine quand même.
Ce sera bien plus court et aussi plus facilement extensible avec ce que tu proposes.
En fait, j'utilise déjà un Callback pour chaque interface mais pas du tout de cette façon.
J'ai une interface qui gère la lecture d'un fichier compliqué et pour chaque section du fichier, j'ai une procédure spécifique pour chaque interface.

Exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
procedure IReader.ListSection1(OnReturnSection1: ReturnSection1);
begin
  .. p pour chaque ligne trouvée,
  OnReturnSection1(ISection1);
end;

Ce qui m'oblige effectivement à faire soit tri dans l'application appelante si je fais un truc comme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

procedure IReader.ListAny(OnReturnAny: ReturnAny);

Ta méthode me demandera un peu plus de code et d'efforts aujourd'hui mais sera plus efficace et réutilisable pour d'autres fichiers du même genre.

Merci pour ta réponse.
Si j'ai un souci pour l'implémentation, je reviendrai quémander un conseil

[ShaiLeTroll]

Ah oui, je faisais cela avec des Record ce genre de fichier aux enregistrements de forme variable : le format NX CCAM en 2004 avec un bon vieux "case of" sur le numéro de header et selon le type un second niveau de "case of", voire un troisième niveau, tout à coup de transtypage de record pour décoder le fichier sans effort.

Pour les fichiers binaires ou texte à longueur fixe
Je sépare maintenant souvent le Reader, son seul but est de produire des record, rien de plus, c'est purement technique, cela évite les Copy(N, M) qui sont sources de problème.
Ensuite, par dessus j'ai des objets métiers qui exploite le Reader (conversion, contrôle de cohérence, règle de métier, workflow ...) qui en ressortent des objets plus facile à manipuler

Et j'ai déjà géré du versionning avec cette méthode pour être capable de lire plusieurs versions du même format de fichier, seul le reader change, les objets métiers restent les mêmes, et justement là entre parfois des Interface pour gérer des extensions (souvent les données absentes sont gérées par des valeurs neutres ou par défaut)

[Papy214]

C'est bien ça. Ce sont des fichiers avec des sections contenant des enregistrements de taille fixe.
Ca porte aussi un autre nom pour les échanges standardisés entre compagnie d'assurance par exemple mais je ne me souviens plus du nom .
Là, les lignes peuvent être composées de nombreux éléments et je devais trouver une solution pour sortir la lecture des données du programme principal déjà bien assez compliqué.

[Papy214]

Ben pour un code soit-disant plein de fautes parce qu'écrit hors Delphi, ça mérite 9,9 / 10.
Il manquait uniquement un r dans TDictionary et un ; à la fin d'une déclaration.

Je te savais déjà parmi les meilleurs mais là, chapeau bas !

J'ai fait un petit proto pour bien appréhender le système et ça fonctionne.
Il ne reste plus qu'à intégrer le système à mon code existant.

La seule chose que Delphi refuse c'est le "AGUID := AInterface;" dans IsRegisteredGUID
Erreur de types incompatibles.
Mais ça fonctionne sans, donc pas grave du tout.

Merci encore

[Papy214]

J'ai oublié de préciser que le GUID dans une constante, ça fonctionne.