옵서버 패턴이있는 유니티 레지스트리, 어떻게?

Question

나는 관찰자 패턴을 구현하는 관찰자들의 집합을 취하는 구체적인 클래스를 가지고있다. 나는 관측자 목록을 주입하는 공사입니다.

Unity를 사용하여 구현체와 Concret을 등록하는 방법은 무엇입니까?

예 :

public class MyRegistry : UnityRegistry 
{ 
    public MyRegistry() 
    { 
     Register<IMyService, MyService>(); 
     Register<IObserver, Ob1>().WithName("observer1"); 
     Register<IObserver, Ob2>().WithName("observer2"); 
    } 
} 

Answer 1

.

public class MyService : IMyService 
{ 
    private IObserverManager observerManager; 

    public MyService(IObserverManager obsManager){ 
      this.observerManager = obsManager; 
    } 

    public void MyMethod(MyObject myObject){ 

     IObserver[] observers = this.observerManager.GetObservers(); 
     foreach(var ob in observers){ 
       ob.Execute(myObject); 
     } 
    } 
} 

public class ObserverManager : IObserverManager { 
    public List<IObserver> GetObservers(){ 
     ... some code to return the list of observers 
    } 

    public void RegisterObserver(IObserver obs) 
    { 
     ... add obs to list of obs 
    } 
} 

public class Ob1 : IObserver{ 
     public void Execute(MyObject obj){ 
      //do something 
     } 
} 

public class Ob2 : IObserver{ 
     public void Execute(MyObject obj){ 
      //do something 
     } 
} 

public class StrategyResolver : IStrategyResolver 
{ 
    private IUnityContainer container; 

    public StrategyResolver(IUnityContainer c) 
    { 
     this.container = c; 
    } 

    public T Resolve<T>(String namedStrategy){ 
     return this.container.Resolve<T>(namedStrategy); 
    } 
} 

public class MyRegistry : UnityRegistry 
{ 
    private IUnityContainer container; 

    public MyRegistry(IUnityContainer c) 
    { 
     this.container = c; 
    } 

    public MyRegistry(){ 
     this.container.RegisterType<IObserverManager, ObserverManager>(); 
     this.container.RegisterType<IMyService, MyService(); 
     this.container.RegisterType<ISomeClass, SomeClass>(); 
     this.container.RegisterType<IObserver, ObserverA>("CategoryA"); 
     this.container.RegisterType<IObserver, ObserverB>("CategoryB"); 
     this.container.RegisterType<IStrategyResolver, StrategyResolver>(); 
    } 
} 

public class SomeClass : ISomeClass 
{ 
    private IObserverManager observerManager; 
    private IStrategyResolver strategyResolver; 

    public SomeClass(IObserverManager oManager, IStrategyResolver sResolver) 
    { 
     this.observerManager = oManager; 
     this.strategyResolver = sResolver; 
    } 

    public void Process(MyObject obj) 
    { 
     IObserver obs = this.strategyResolver.Resolve<IObserver>(obj.Category); 
     this.observerManager.RegisterObserver(obs); 

     ...etc.... 
    } 
} 

희망 하시겠습니까?

Answer 2

내가 이런 짓을 할 것이다 : 제대로 관찰자의 배열을 해결 할 수있을 것입니다 당신은 단지 IObserver과 일치의 등록에 대한 이름을 줄 필요가

public class MyService : IMyService 
{ 
    private IObserver[] _observers; 
    public MyService(params IObserver[] observers){ 
      _observers = observers; 
    } 

    public void MyMethod(MyObject myObject){ 

     foreach(var ob in _observers){ 
       ob.Execute(myObject); 
     } 
    } 
} 

public class Ob1 : IObserver{ 
     public void Execute(MyObject obj){ 
      //do something 
     } 
} 

public class Ob2 : IObserver{ 
     public void Execute(MyObject obj){ 
      //do something 
     } 
} 

public class MyRegistry : UnityRegistry 
{ 
    public MyRegistry(){ 
     ///What Goes Here?? 
    } 
}