If ServiceB
needs ServiceA
的结果让它正常工作那么为什么不呢ServiceB
根据ServiceA
?
public interface IService
{
void Execute();
}
public class ServiceA : IService
{
public void Execute() { ... }
}
class ServiceB : IService
{
public ServiceB(IService service)
{
Service = service;
}
public void Execute() { ... }
public IService Servie { get; set; }
}
那么如果你执行了所有Service
在集合中,您可以添加ServiceBase
确保该服务仅执行一次:(完整示例)
在此基本实现上,您可以添加: 异步Execute
, 执行的线程安全检查InnerExecute
,Flyweight工厂用于具体的生成IService
, 有一个ResponseBase
以及每个的派生响应Service
....
public class ServiceResponse { }
public interface IService
{
ServiceResponse Execute();
}
public abstract class ServiceBase : IService
{
public ServiceResponse Execute()
{
if (_response == null)
{
_response = InnerExecute();
}
return _response;
}
public abstract ServiceResponse InnerExecute();
private ServiceResponse _response;
}
public class ServiceA : ServiceBase
{
public override ServiceResponse InnerExecute()
{
return new ServiceResponse();
}
}
public class ServiceB : ServiceBase
{
public ServiceB(IServiceFactory serviceFactory)
{
ServiceFactory= serviceFactory;
}
public override ServiceResponse InnerExecute()
{
return ServiceFactory.GetServices(ServicesTypes.ServiceA).Execute();
}
public IServiceFactory ServiceFactory { get; set; }
}
无论谁使用这些Service
s:
public enum ServicesTypes
{
ServiceA,
ServiceB....
}
public interface IServiceFactory
{
IEnumerable<IService> GetServices();
IService GetServices(ServicesTypes servicesTypes);
}
public class SomeOtherThatExecuteServices
{
public SomeOtherThatExecuteServices(IServiceFactory serviceFactory)
{
ServiceFactory = serviceFactory;
}
public IEnumerable<ServiceResponse> ExecuteServices()
{
return ServiceFactory.GetServices()
.Select(service => service.Execute());
}
public IServiceFactory ServiceFactory { get; set; }
}
您可能希望通过某些映射键来访问工厂,并且可能需要在SomeOtherThatExecuteServices
但所有这些都会让你走上正确的道路(+使用一些适当的 IoC 容器)