1

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

我不喜欢每个服务都有一个端点的想法……随着我的存储库的增长，将来维护可能会成为问题……

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

商务服务A：

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

商务服务乙：

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

我的单一服务偏向于将每个服务的关注点分开。请注意，它的构造函数依赖于上述两个业务服务，将使用 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();

我非常感谢任何意见或其他建议。

4

1 回答 1

0

多个端点没有什么问题——它是过程的一部分。然而，错误在于在多个端点上复制功能。需要多少“UpdateThis's”或“AddThat's”开发人员？这可能会失控并导致维护头痛。看看你的构造函数，它会随着你添加新服务并将它们整合到一个服务中而不断增长。

考虑粗粒度而不是细粒度。

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

所以，它看起来像这样：

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

所以，现在您已经删除了细粒度的方法，并用粗粒度的方法取而代之。如果您想了解更多详情，请告诉我。

于 2012-12-04T18:59:38.637 回答