WCF: buscando las mejores prácticas al tener contratos múltiples que comparten métodos comunes

Question

Tengo la intención de tener un módulo principal que exponga las interfaces para que otros grandes módulos (clientes diferentes) se comuniquen con él. Si, por ejemplo, hay grupos de métodos:

void Method_A(); 
void Method_B(); 
void Method_X1(); 

para exponer a un tipo de clientes (módulo "X1") y:

void Method_A(); 
void Method_B(); 
void Method_X2(); 

para exponer a otro tipo de clientes (módulo "X2 ") y sabiendo que Method_A y Method_B deben tener la implementación exacta ... entonces, ¿cómo puedo diseñar mejor la arquitectura del servicio (en términos de servicios y contratos)?

¿Hay alguna posibilidad de implementar Method_A y Method_B ​​solo una vez (no 2 veces en diferentes implementaciones contractuales)?

¿Cómo me beneficiaré de la herencia de la interfaz cuando uso WCF?

Gracias a todos con anticipación y háganmelo saber si necesito hacerlo más claro!

@marc_s ... Realmente agradecería su punto de vista ...

Answer 1

Las clases pueden heredar los métodos que satisfacen una interfaz, lo que podría tener una interfaz IServiceBase y ServiceBase clase que implementa simplemente Method_A y Method_B , luego seleccione los métodos únicos en interfaces separadas, finalmente combínelos en clases que hereden ServiceBase e implemente Interface1 o Interface2. por ejemplo:

[ServiceContract] 
public interface IServiceBase 
{ 
    [OperationContract] 
    void Method_A(); 

    [OperationContract] 
    void Method_B(); 
} 

[ServiceContract] 
public interface IService1 : IServiceBase 
{ 
    [OperationContract] 
    void Method_X1(); 
} 

[ServiceContract] 
public interface IService2 : IServiceBase 
{ 
    [OperationContract] 
    void Method_X2(); 
} 

public abstract class ServiceBase : IServiceBase 
{ 
    void Method_A() 
    { 
     ... implementation here ... 
    } 

    void Method_B() 
    { 
     ... implementation here ... 
    } 
} 

public class Service1 : ServiceBase, IService1 
{ 
    void Method_X1() 
    { 
     ... implementation here ... 
    } 
} 

public class Service2 : ServiceBase, IService2 
{ 
    void Method_X2() 
    { 
     ... implementation here ... 
    } 
} 

Answer 2

Me han llamado!?!?! :-)

Si usted tiene una interfaz

public interface IServiceA 
{ 
    void Method_A(); 
    void Method_B(); 
    void Method_X1(); 
} 

y una segunda

public interface IServiceB 
{ 
    void Method_A(); 
    void Method_B(); 
    void Method_X2(); 
} 

puede compartir absolutamente el código de implementación para los dos métodos comunes a nivel de servidor.

, debes crear dos clases MethodAHandler y MethodBHandler en su servidor, en una biblioteca de clases común (o en dos asambleas separadas, común), y entonces se podría usar algo como:

using MethodHandlers; // contains the two method handlers 

public class ServiceA : IServiceA 
{ 
    public void Method_A() 
    { 
     MethodAHandler hnd = new MethodAHandler(); 
     hnd.HandleMethodCall(); 
    } 

    public void Method_B() 
    { 
     MethodBHandler hnd = new MethodBHandler(); 
     hnd.HandleMethodCall(); 
    } 

    public void Method_X1() 
    { 
     // handle method X1 call here or delegate to another handler class 
    } 
} 

y para el segundo servicio:

using MethodHandlers; // contains the two method handlers 

public class ServiceB : IServiceB 
{ 
    public void Method_A() 
    { 
     MethodAHandler hnd = new MethodAHandler(); 
     hnd.HandleMethodCall(); 
    } 

    public void Method_B() 
    { 
     MethodBHandler hnd = new MethodBHandler(); 
     hnd.HandleMethodCall(); 
    } 

    public void Method_X2() 
    { 
     // handle method X2 call here or delegate to another handler class 
    } 
} 

en el lado del servidor, que tiene clases .NET y puede compartir código entre dos absolutamente aplicación de servicio independiente a través de una biblioteca de clases común o lo que encontrar el mejor enfoque para tú.