Windsor estilo de Vida instância Compartilhada por Gráfico

Question

Eu tenho 2 tipos de ViewModel do

      public class ViewModelA 
      {
          IService service;
          private ViewModelB childViewModel; 

           public ViewModelA(IService service,ViewModelB childViewModel)
           {
               this.service = service;
               this.childViewModel = childViewModel;
           }

           public ViewModelB ChildViewModel
           {
                get { return childViewModel; } 
            } 
      }  

      public class ViewModelB 
      {
          IService serivce;  
          public ViewModelB(IService service)
          {
              this.service = service;
          }  
      } 

Eu tenho um Serviço registrado em Windsor Recipiente :

     public class Service : IService {}

     container.Register(Component.For<IService>()
                  .ImplementedBy<Service >().LifeStyle.Transient); 

Eu quero ViewModelA e ViewModelB para compartilham a mesma instância do IService.

Eu Não wan não todas as instâncias de ViewModelA e ViewModelB para compartilham a mesma instância.

Cada Pai/Filho Par teria o seu próprio exemplo , eu wan não para conseguir isso, usando DependencyInjection isso pode ser feito ?

Eu wan não esta a ser feito por meio de Injeção de Dependência, desde que eu tenha uma hierarquia completa de ViewModels em Um e não apenas um (B) viewmodel.

VM A -> VM B -> VM C -> VM D ...(e vamos dizer que vou dar sobre todos alfabeto) todos estes precisam compartilhar a mesma instância do IService.

e outra instância de Um e pessoa falecidas gostaria de compartilhar uma instância diferente do IService.

Answer 1

O que funcionou para mim está usando :Estilo De Vida BoundTo

    container.Register(Component.For<IService>()
            .ImplementedBy<Service>()
            .LifeStyle.BoundTo<ViewModelA>());

Gráfico :

     public class ViewModelAConductor 
     {
         private List<ViewModelA> rootViewModels = new List<ViewModelA>();
         public ViewModelAConductor()
         {
              ViewModelA a1 = container.Resolvce<ViewModelA>(); 
              rootViewModels.Add(a1);

              ViewModelA a2 = container.Resolvce<ViewModelA>(); 
              rootViewModels.Add(a2); 
         }
     }

     public class ViewModelA
     {
          ViewModelB viewModelB;
          IService service;

          public ViewModelA(IService service,ViewModelB viewModelB) 
          {
              this.service = service;
              this.viewModelB = viewModelB;
          }               
     }

     public class ViewModelB
     {
          ViewModelC viewModelC;
          IService service;

          public ViewModelA(IService service,ViewModelC viewModelC) 
          {
              this.service = service;
              this.viewModelC = viewModelC;
          }               
     }  

     public class ViewModelC
     {
          IService service;

          public ViewModelA(IService service) 
          {
              this.service = service;                 
          }               
     }  

Todos os ViewModels injetado sob o Gráfico de a1 tem a mesma instância do IService.

Todos os ViewModels injetado sob o Gráfico de a2 tem a mesma instância do IService.

Answer 2

Você pode ser capaz de usar Escopo De Estilos De Vida.Aqui está um exemplo de alguns testes de unidade que parecem fazer o que você deseja:

[Fact]
public void VMsInSameScopeSharesService()
{
    var container = new WindsorContainer();
    container.Register(Component.For<ViewModelA>().LifestyleTransient());
    container.Register(Component.For<ViewModelB>().LifestyleTransient());
    container.Register(Component
        .For<IService>().ImplementedBy<NullService>().LifestyleScoped());

    using (container.BeginScope())
    {
        var a = container.Resolve<ViewModelA>();

        Assert.Equal(a.service, a.childViewModel.service);
    }
}

[Fact]
public void VMsInDifferentScopesDoNotShareServices()
{
    var container = new WindsorContainer();
    container.Register(Component.For<ViewModelA>().LifestyleTransient());
    container.Register(Component.For<ViewModelB>().LifestyleTransient());
    container.Register(Component
        .For<IService>().ImplementedBy<NullService>().LifestyleScoped());

    IService service1;
    using (container.BeginScope())
    {
        var a = container.Resolve<ViewModelA>();

        service1 = a.service;
    }
    IService service2;
    using (container.BeginScope())
    {
        var a = container.Resolve<ViewModelA>();

        service2 = a.service;
    }

    Assert.NotEqual(service1, service2);
}

No entanto, isso é bastante exótica requisito, o que me faz perguntar por que você quer que ele se comporte exatamente como esta, ou se você não conseguiu estruturar seu código de forma que gostaria de fazer isso mais simples.