¿Cuál es el mejor patrón para la comunicación bidireccional entre clases?

Question

Tengo clases que necesitan comunicarse entre sí. El problema es que si uno hace que el otro contenga el otro (una relación entre padres e hijos), entonces las cosas se vuelven complicadas. O bien debe pasar una instancia del padre al hijo, (entonces, ¿cuál creará primero si está usando la inyección de dependencia) o puede usar delegados/eventos? Pero quiero hacer cumplir el hecho de que el padre debe ser capaz de manejar el evento que el niño plantea. No estoy muy seguro de cómo hacer eso. Tampoco quiero múltiples suscriptores al evento.

La relación padre-hijo simplemente se siente mal para la comunicación bidireccional. Desafortunadamente no es un caso que uno de los objetos siempre inicie y el otro responda. Cualquiera puede iniciar y el otro debe responder.

¿Hay algún otro patrón que me falta?

ACTUALIZACIÓN: Lo siento, esto es bastante difícil de explicar. Olvidé agregar que cuando una clase envía un mensaje a otra clase, no espera la respuesta de inmediato. La respuesta viene de forma asíncrona, por lo que necesita una instancia del padre para llamar al método correcto o un delegado/evento. Lo siento, el siguiente ejemplo es pseudo código. Con suerte, es suficiente para tener la idea. Debería mirar el patrón del mediador.

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

Es un poco difícil dar una buena respuesta, ya que su pregunta es un poco abstracta. Pero, ¿qué pasa con el patrón Mediator?

Answer 2

Tal vez se debe utilizar un programa previo:

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); 
    } 
} 

Ahora, tanto A como B son felizmente inconscientes de la otra.

Answer 3

Es posible que desee mirar el Domain Events Pattern y el código de muestra de Udi Dahan. Tiene el mismo principio básico que el fragmento de código publicado por Chad. Martin Fowler también ha escrito sobre el patrón y proporciona un poco más de información sobre el tema.

Answer 4

Este es un ejemplo, también se puede hacer utilizando 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

Haga un objeto intermedio que contenga los detalles de comunicación e inyéctelo tanto en A como en B?