复合设计模式:如何将结果从一个组件传递到另一个组件?
Composite design pattern: how to pass results from one component into another?
我有以下代码:
interface IService
{
void Execute();
}
class ServiceA : IService
{
public void Execute() { ... }
}
class ServiceB : IService
{
public void Execute() { ... }
}
class ServiceComposite : IService
{
List<IService> _services = new List<IService>();
public ServiceComposite()
{
_services.Add(new ServiceA());
_services.Add(new ServiceB());
}
public void Execute()
{
foreach (IService service in _services)
{
service.Execute();
}
}
}
问题是 ServiceB 依赖于 ServiceA 的某些结果。我的想法是创建容器 class 用于存储结果,然后将其注入到 ServiceA 和 ServiceB 中:
class ServiceResults
{
public string SomeProperty {get; set;}
}
public ServiceComposite()
{
ServiceResults result = new ServiceResults();
_services.Add(new ServiceA(result));
_services.Add(new ServiceB(result));
}
我想知道这是否是解决问题的最佳方法。也许它违反了一些我不知道的原则或规则,或者只是"code smell"。执行此操作的更好方法是什么?
如果 ServiceB
需要 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
执行的线程安全检查、生成特定 [=21] 的享元工厂=], 有一个 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 容器)
我有以下代码:
interface IService
{
void Execute();
}
class ServiceA : IService
{
public void Execute() { ... }
}
class ServiceB : IService
{
public void Execute() { ... }
}
class ServiceComposite : IService
{
List<IService> _services = new List<IService>();
public ServiceComposite()
{
_services.Add(new ServiceA());
_services.Add(new ServiceB());
}
public void Execute()
{
foreach (IService service in _services)
{
service.Execute();
}
}
}
问题是 ServiceB 依赖于 ServiceA 的某些结果。我的想法是创建容器 class 用于存储结果,然后将其注入到 ServiceA 和 ServiceB 中:
class ServiceResults
{
public string SomeProperty {get; set;}
}
public ServiceComposite()
{
ServiceResults result = new ServiceResults();
_services.Add(new ServiceA(result));
_services.Add(new ServiceB(result));
}
我想知道这是否是解决问题的最佳方法。也许它违反了一些我不知道的原则或规则,或者只是"code smell"。执行此操作的更好方法是什么?
如果 ServiceB
需要 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
执行的线程安全检查、生成特定 [=21] 的享元工厂=], 有一个 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 容器)