Question

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

我不喜欢每个服务都有一个端点的想法......随着我的存储库的增长，将来可能会出现问题.......

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

商业服务A：

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

我的单项服务部分针对每项服务的不同问题。请注意，它的构造函数取决于上面的两个业务服务，将使用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”或“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);

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

WCF为专家避免了太多的端点

1 个答案: