Syntaxe delphi vers C#

Bonjour,

En Delphi j'utilise souvent les procédure et fonction "of object". J'essai de faire la même chose en C#

Exemple Delphi :
Déclaration de la procédure "of object"

Code:

---

1 2	TLogProc = procedure(Const Texte : String) of object;

---

Branchement dans une classe

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

TMaClasse = class(TMonAncetre) private FLog : TLogProc; ... procedure DoLog(Const Texte : String); public property LogProc : TLogProc write FLog; ... procedure FaireQuelqueChoseEtLeLogger; end;   procedure TMaClasse .DoLog(Const Texte : String); begin if (Assigned(FLog)) then FLog(Texte); end;   procedure TMaClasse .FaireQuelqueChoseEtLeLogger; begin ... DoLog('Un texte de Log'); ... end;

---

Utilisation

Code:

---

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

procedure FrmTest.Logguer(Const Texte : String); begin Memo.Lines.Add(Texte); end;   procedure FrmTest.FaireQuelqueChose; begin MonObjet := TMaClasse .Create; try MonObjet.LogProc := Logguer; MonObjet.FaireQuelqueChoseEtLeLogger; finally if (Assigned(MonObjet)) then FreeAndNil(MonObjet) end; end;

---

J'ai pensé au délégué pour le faire mais je ne suis pas encore très à l'aise avec.
Suis-je sur la bonne voie et dans ce cas pouvez-vous m'éclairer un peu plus sur sur la mise en oeuvre ?
Ou alors est-ce que je me trompe complètement ? Mais dans ce cas, est-ce possible et comme le faire ?

Quand tu veux traduire du Japonais vers le Russe, il te faut trouver quelqu'un qui parle le Japonais (Delphi) et le Russe (c#)... ce n'est pas simple.. alors que trouver quelqu'un qui parle Russe et Anglais c'est facile.

Si tu me traduis "fonctionnellement" ce que tu veux faire, je pense que je pourrais t'aider... malheureusement pour toi je ne lis pas le Japonais Delphi !

Citation:

---

Envoyé par Er3van

Quand tu veux traduire du Japonais vers le Russe, il te faut trouver quelqu'un qui parle le Japonais (Delphi) et le Russe (c#)... ce n'est pas simple.. alors que trouver quelqu'un qui parle Russe et Anglais c'est facile.

Si tu me traduis "fonctionnellement" ce que tu veux faire, je pense que je pourrais t'aider... malheureusement pour toi je ne lis pas le Japonais Delphi !

---

En gros ce bout de code en Delphi me permet d'afficher dans la fenêtre et en temp réel le log de ce qui se passe.
Une sorte d'évenement OnLogEvent à affecter à ma volée à l'objet qui fait le traitement.

L'utilisation des procédure "of object" me permet d'utiliser une fonction déclarée dans le code qui gère l'interface graphique à l'intérieur d'un objet qui n'a aucun rapport avec une quelconque interface graphique. L'objet ne connais rien de l'interface graphique et ne dois d'ailleurs surtout pas y être liée. Je lui affecte donc une procédure "of object" qui va simplement prendre en paramètre des données simple que la procédure de l'interface graphique sera en mesure d'utiliser comme elle veut.

J'ai tout de même résolu mon problème (il s'avérait qu'il y avait une utilisation des délégués que j'avais complètement zappée).
Je donne la solution si ça interresse quelqu'un

Déclaration:

Code:

---

public delegate void TLogProc(String Texte);

---

Branchement dans la classe:

Code:

---

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

public class TMaClasse : TMonAncetre { TLogProc FLog; public TLogProc LogProc { set { FLog = value; } }   ...   void DoLog(String Texte) { if (FLog != null) FLog(Texte);   } public void FaireQuelqueChoseEtLeLogger() { ... DoLog("Un texte de Log"); ... } }

---

Utilisation:

Code:

---

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

public partial class FrmTest : Form { ... void Logguer(String Texte) { Memo.AppendText(Texte); }   void FaireQuelqueChose() { TMaClasse MonObjet = new TMaClasse(); MonObjet.LogProc = Logguer; MonObjet.FaireQuelqueChoseEtLeLogger(); } }

---

J'aurais personnellement utilisé une interface (mais je me plante peut être complètement)

Tu déclare un interface qui déclare la fonction log.

Code:

---

1 2 3

interface ILogger { void log(string msg); }

---

Ta classe qui doit log accepte un paramètre du type de ton interface

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

class DoSomething { private ILogger logger; public DoSomething(ILogger logger) { this.logger = logger; }   public void logSomething() { if (logger != null) { logger.log("coucou"); } } }

---

Dans ton formulaire, tu implémente l'interface

Code:

---

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

public partial class Form1 : Form, ILogger { public Form1() { InitializeComponent(); }   public void log(string msg) { MessageBox.Show(msg); }   private void Form1_Load(object sender, EventArgs e) { var doSomething = new DoSomething(this); doSomething.logSomething(); } }

---

L'avantage de ta solution est de pouvoir "brancher" plusieurs listener sur le delegate (si je ne dis toujours pas de bêtises), mais je trouve ça moins lisible personnellement.

Sauf que si, je veux éviter de répéter ceci :

Code:

---

1 2 3

if (logger != null) { logger.log("coucou"); }

---

il va falloir que je déclare une procédure pour le faire et le code ressemblera à ceci

Code:

---

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

class DoSomething { private ILogger logger; public DoSomething(ILogger logger) { this.logger = logger; }   void Log(string texte) { if (logger != null) { logger.log("coucou"); }   public void logSomething() { Log("coucou"); } } }

---

Maitenant comparons les deux versions :
-Nous avons tous les deux une déclaration du mécanisme à utiliser (moi un delegate, toi une interface)
-Nous déclarons tous les deux un type privé dans la classe pour l'utiliser.
-Nous l'utilisons de la même façon au sein de la classe

La seule différence que je vois, c'est que j'affecte mon delegate via une propriété et que tu passes l'interface via le constructeur .
C'est précisement ce que je chercher à éviter car pour rester cohérent il faudrait que je rajoute un paramètre à mon constructeur à chaque fois que je veux implémenter une autre interface ou alors il faudrait que je multiplie les constructeurs en fonction du comportement que je veux avoir (ce qui est loin de simplifier les chose).

En plus, comme tu le souligne à juste titre, je perds la possibilité de brancher plusieurs listeners.
Sans parler que ce concept est connu par mes collegue alors que le principe d'interface est encore, pour eux, une notion très vague. Le jour où j'ai parlé d'inversion de contrôle grace aux interface, ils m'ont tous regardé comme si j'étais un extra-terrestre...

Comme je l'ai bien précisé, cela me paraissait plus simple, de là tout l’intérêt de confronter 2 méthodes ;)