1

这个问题是关于Microsoft WCF上下文中的编程和最佳实践的理论问题，特别关注Web 服务。

Web服务中的继承

考虑一种情况，当我们需要定义一些功能时。我们希望使用 Web 服务向世界公开这些功能。功能由接口建模（在处理分布式系统等时这是一个非常好的实践）。所以我们有如下内容：

///
/// Functionalities for a certain context, calling them A functionalities
///
public interface IFunctionalitiesA {
   FunctionalityA1ResMsg FunctionalityA1(FunctionalityA1ReqMsg msg);
   FunctionalityA2ResMsg FunctionalityA2(FunctionalityA2ReqMsg msg);
   FunctionalityA3ResMsg FunctionalityA3(FunctionalityA3ReqMsg msg);
}

///
/// Functionalities for a certain context, calling them B functionalities
///
public interface IFunctionalitiesB {
   FunctionalityB1ResMsg FunctionalityB1(FunctionalityB1ReqMsg msg);
   FunctionalityB2ResMsg FunctionalityB2(FunctionalityB2ReqMsg msg);
}

///
/// Functionalities for a certain context, calling them C functionalities
///
public interface IFunctionalitiesC {
   FunctionalityC1ResMsg FunctionalityC1(FunctionalityC1ReqMsg msg);
   FunctionalityC2ResMsg FunctionalityC2(FunctionalityC2ReqMsg msg);
   FunctionalityC3ResMsg FunctionalityC3(FunctionalityC3ReqMsg msg);
   FunctionalityC4ResMsg FunctionalityC4(FunctionalityC4ReqMsg msg);
}

///
/// Functionalities for a certain context, calling them D functionalities
///
public interface IFunctionalitiesD {
   FunctionalityD1ResMsg FunctionalityD1(FunctionalityD1ReqMsg msg);
   FunctionalityD2ResMsg FunctionalityD2(FunctionalityD2ReqMsg msg);
}

现在让我们考虑所有这些功能都可以通过一些服务来实现。但是，拥有一个服务来实现它们并不是强制性的。一个服务可以实现其中的一些，而另一个服务可以实现其中的另一个子集。我特别要求考虑以下情况：

///
/// This service implements functionalities A and B.
///
public class ServiceS1 : IFunctionalitiesA, IFunctionalitiesB {
   ... /* Implementing interfaces methods */
}

///
/// This service implements functionalities C and D.
///
public class ServiceS2 : IFunctionalitiesC, IFunctionalitiesD {
   ... /* Implementing interfaces methods */
}

请特别注意，这两个服务将在内部创建一些重要的东西。我的意思是他们拥有只有他们才能访问的资源，例如第一个服务可能会保留一个元素数组，第二个也是如此。简而言之，它们不是虚拟服务，它们具有状态和资源，并且受到外部访问的保护（因此它们被声明为publicor protected）。

现在让我们考虑我们想要实现一个服务，可能在不同的站点上运行，它实现了所有的功能。在处理各自实现的方法时，该服务的行为将与上述两个完全相同。不幸的是，我们不能从它们两者中得出。所以我们需要这样做：

public class GlobalService : 
   IFunctionalitiesA, IFunctionalitiesB, IFunctionalitiesC, IFunctionalitiesD {
   ...
}

封装……可以是答案吗？

问题是：

如何重用实现整体功能子集的两个服务中的逻辑？

我最终考虑做这样的事情：

public class GlobalService : 
   IFunctionalitiesA, IFunctionalitiesB, IFunctionalitiesC, IFunctionalitiesD {

   ///
   /// Encapsulating ServiceS1
   ///
   protected ServiceS1 srvs1;

   ///
   /// Encapsulating ServiceS2
   ///
   protected ServiceS2 srvs2;

   public GlobalService() {
      this.srvs1 = new ServiceS1();
      this.srvc2 = new ServiceS2();
   }

   ///
   /// Methods are redirected internally to the reused implementation
   /// This is to be done for all methods
   ///
   public FunctionalityA1ResMsg FunctionalityA1(FunctionalityA1ReqMsg msg) {
      return thissrvs1.FunctionalityA1(msg);
   }

   ...

}

通过这样做，我可以重用已实现的逻辑，而无需一次又一次地创建冗余代码。当然，这可能是一种仅限于某些情况的方法，但在这些情况下（毕竟没有那么严格）。

这是解决问题的好方法吗？你有不同的想法吗？

4

0 回答 0