WCF为专家避免太多端点

Question

我有很多已经实施的企业服务，并且我将它们公开为WCF的服务。

我不喜欢这个主意，有一个端点到每个服务.....它可能是在未来保持我的资料库增长问题.......

I' d想知道wcf的专家意见，如果下面的代码是一个好方法，那么我可以继续使用这个解决方案。

业务服务答：

[ServiceContract] 
public interface IServiceA 
{ 
    [OperationContract] 
    object AddA(object a); 
    [OperationContract] 
    object Update(); 
} 

业务服务B：

[ServiceContract] 
public interface IServiceB 
{ 
    [OperationContract] 
    object AddB(object b); 
    [OperationContract] 
    object Update(); 
} 

具体实施服务A

public class ConcreteServiceA : IServiceA 
{ 
    public object AddA(object a) 
    { 
     Console.WriteLine("ConcreateServiceA::AddA"); 
     return null; 
    } 

    public object Update() 
    { 
     Console.WriteLine("ConcreateServiceA::Update"); 
     return null; 
    } 
} 

混凝土实施服务B

public class ConcreteServiceB : IServiceB 
{ 
    public object AddB(object b) 
    { 
     Console.WriteLine("ConcreateServiceB::AddB"); 
     return null; 
    } 

    public object Update() 
    { 
     Console.WriteLine("ConcreateServiceB::Update"); 
     return null; 
    } 
} 

我的单一服务是局部，分离成每个服务的关注。 注意it's构造取决于商务服务上面，将使用IoC的

部分的构造

public partial class WCFService 
{ 
    IServiceA _a; 
    IServiceB _b; 
    public WCFService() 
     : this(new ConcreteServiceA(), new ConcreteServiceB()) 
    { 

    } 
    public WCFService(IServiceA serviceA, IServiceB serviceB) 
    { 
     _a = serviceA; 
     _b = serviceB; 
    } 
} 

部分类只实现IServiveA

public partial class WCFService : IServiceA 
{ 
    object IServiceB.AddB(object b) 
    { 
     return _b.AddB(b); 
    } 

    object IServiceB.Update() 
    { 
     return _b.Update(); 
    } 

} 

注射部分课程只实施IServiceB

public partial class WCFService : IServiceB 
{ 
    object IServiceA.AddA(object a) 
    { 
     return _a.AddA(a); 
    } 

    object IServiceA.Update() 
    { 
     return _a.Update(); 
    } 
} 

而在客户端，我用这样的：

 var endPoint = new EndpointAddress("http://localhost/teste"); 
     ChannelFactory<IServiceA> _factoryA = new ChannelFactory<IServiceA>(new BasicHttpBinding(), endPoint); 
     IServiceA serviceA = _factoryA.CreateChannel(); 
     serviceA.Update(); 

     var netTcpEndPoint = new EndpointAddress("net.tcp://localhost:9000/teste"); 
     ChannelFactory<IServiceB> _factoryB = new ChannelFactory<IServiceB>(new NetTcpBinding(), netTcpEndPoint); 
     IServiceB serviceB = _factoryB.CreateChannel(); 
     serviceB.Update(); 

我真的很感激任何意见或其他建议。

Answer 1

多个端点没有什么问题 - 这是过程的一部分。然而，什么是错误的是重复多个端点的功能。开发人员需要多少“UpdateThis's”或“AddThat”？这可能会失控并导致维修头痛。只要看看你的构造函数，当你添加新的服务并将它们合并成一个服务时，它会不断增长和增长。

认为粗粒度不细粒度。

作为替代方案，也许您可​​以尝试将请求对象作为参数传递并返回响应对象。这种方法可以简化你的代码，并帮助你避免你在文章中提到的维护问题，并给你一个建议。

因此，它看起来是这样的：

// Your service will return a very generic Response object 
public interface IService 
    { 
     Response YourRequest(Request request); 
    } 

// Your service implementation 
public partial class WCFService : IService 
    { 
     Response IService.YourRequest(Request request) 
     { 
      //inspect the Request, do your work based on the values 
      //and return a response object    
     } 
    } 

// Your request object 
public class Request() 
    { 
     object YourClass{get;set;} 
     DoWhat Action{get;set;} //enum, constants, string etc. 
     int ID {get; set;} 
    } 

// Your response object 
    public class Response() 
     { 
      bool Success {get; set;} 
     } 

// Create Request object 
var request = new Request(){YourClass = YourClassName , Action DoWhat.Update(), ID=1}; 

// Your service call 
var endPoint = new EndpointAddress("http://localhost/teste"); 
       ChannelFactory<IService> _factory = new ChannelFactory<IService>(new BasicHttpBinding(), endPoint); 
       IService service = _factory.CreateChannel(); 
var response = service.YourRequest(request); 

所以，现在你已经删除了精细的方法，并与粗粒度一个替代它。让我知道你是否想要更多的细节。