Quel est le meilleur modèle pour la communication bidirectionnelle entre les classes?

Question

J'ai des cours qui doivent communiquer entre eux. Le problème est que si vous faites l'un contenir l'autre (une relation parent-enfant) alors les choses deviennent difficiles. Vous devez soit passer une instance du parent dans l'enfant, (alors lequel créez-vous en premier si vous utilisez l'injection de dépendance) ou vous pouvez utiliser des délégués/événements. Mais je veux imposer le fait que le parent doit être capable de gérer l'événement que l'enfant soulève. Pas trop sûr de savoir comment faire ça. Je ne veux pas non plus de plusieurs abonnés à l'événement.

La relation parent-enfant se sent juste mal pour la communication bidirectionnelle. Malheureusement, il ne s'agit pas d'un cas où l'un des objets initie toujours et l'autre répond. L'un peut initier et l'autre devrait répondre.

Y a-t-il un autre motif qui me manque?

MISE À JOUR: Désolé, c'est assez difficile à expliquer. J'ai oublié d'ajouter que lorsqu'un cours envoie un message à une autre classe, il n'attend pas la réponse immédiatement. La réponse arrive de manière asynchrone, ce qui explique pourquoi vous avez besoin d'une instance du parent pour appeler la bonne méthode ou d'un délégué/événement. Désolé l'exemple ci-dessous est un pseudo code. Espérons que c'est suffisant pour avoir l'idée. Dois-je regarder le modèle de médiateur.

public class Foo 
    { 
     public void SendMessageAToBar() 
     { 
      MessageA msg = new MessageA(); 
      Bar.ReceiveMessageAFromFoo(msg); 
     } 

     public void ReceiveMessageARespFromBar(MessageAResp msgResp) 
     { 
      //Got a response do something 
     } 

     public void ReceiveMessageBFromBar(MessageB msg) 
     { 
      //Do something msg 
      MessageBResp msgBResp = new MessageBResp(); 
      Bar.ReceiveMessageBRespFromFoo() 
     } 
    } 

    public class Bar 
    { 


     public void ReceiveMessageAFromFoo(MessageA msg) 
     { 
      //DO something. 
      MessageAResp resp = new MessageAResp(); 
      Foo.ReceiveMessageARespFromBar(resp); 
     } 

     public void SendMessageBToFoo() 
     { 
      MessageB msg = new MessageB(); 
      Foo.ReceiveMessageBFromBar(msg); 
     } 

     public void ReceiveMessageBRespFromFoo(MessageBResp msgResp) 
     { 
      //Got a response do something 
     } 
    } 

Answer 1

Il est un peu difficile de fournir une bonne réponse, puisque votre question est un peu abstraite. Mais qu'en est-il du modèle Mediator?

Answer 2

Peut-être que vous devez utiliser un programme d'amorçage:

class Main 
{ 
    void Main(...) 
    { 
     A a = new A(); 
     B b = new B(); 

     a.MessagePosted += (sender, messageArgs) => b.ReadMessage(messageArgs.Message); 
     b.MessagePosted += (sender, messageArgs) => a.ReadMessage(messageArgs.Message); 
    } 
} 

Maintenant, A et B sont parfaitement inconscients les uns des autres.

Answer 3

Vous voudrez peut-être regarder l'exemple de code Domain Events Pattern et Udi Dahan. Il a le même principe de base à l'extrait de code publié par Chad. Martin Fowler a également écrit sur le modèle et fournit un peu plus d'informations sur le sujet.

Answer 4

Ceci est un exemple, peut également être fait en utilisant Interfaces.

public abstract class Attachable 
{ 
    public void Attach(Attachable attachable) 
    { 
     Attached = attachable; 
     attachable.Attach(this); 
    } 

    public Attachable Attached { get; private set; } 
    public abstract void DoSomethingUseful(object argument); 
} 


public class A : Attachable 
{ 
    #region Overrides of Attachable 

    public override void DoSomethingUseful(object argument) 
    { 
     // do something useful 
    } 

    #endregion 
} 

public class B : Attachable 
{ 
    #region Overrides of Attachable 

    public override void DoSomethingUseful(object argument) 
    { 
     // do something useful 

    } 

    #endregion 
} 

// Usage 
A a = new A(); 
B b = new B(); 
a.Attach(b); 

Answer 5

Créer un objet intermédiaire contenant des détails de communication et l'injecter dans A et B?