城堡温莎propogating直列依赖

Question

我想实现对象的构造如下图所示，

using (var context = new DbContext()) 
{ 
    var processor = new Processor(context, new Parser(context, new Logger(context)), new Logger(context)); 
} 

但使用温莎城堡。我正在使用内联依赖关系，如下面的代码所示，但是Castle Windsor文档声明“内联依赖关系不会被传播”Castle Windsor passing arguments。我怎样才能以另一种方式实现这个目标？

using Castle.MicroKernel.Registration; 
using Castle.Windsor; 
using System; 

namespace IOCTesting 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      using (var context = new DbContext()) 
      { 
       var processor = new Processor(context, new Parser(context, new Logger(context)), new Logger(context)); 
      } 

      var container = new WindsorContainer(); 

      container 
       .Register(Component.For<IProcessor>() 
       .ImplementedBy<Processor>()); 

      container 
       .Register(Component.For<IParser>() 
       .ImplementedBy<Parser>()); 

      container 
       .Register(Component.For<ILogger>() 
       .ImplementedBy<Logger>()); 


      //[1] Creating my scope object here. (context) 
      using (var context = new DbContext()) 
      { 
       var processor = container.Resolve<IProcessor>(new { context = context }); 
      } 
     } 
    } 

    public class DbContext : IDisposable 
    { 
     public void Dispose() 
     { 
      Console.WriteLine("DbContext disposed."); 
     } 
    } 

    public class Processor : IProcessor 
    { 
     private readonly DbContext _context; 
     private readonly ILogger _logger; 
     private readonly IParser _parser; 

     //Dependency context passed in is the same object within the scope. See [1] 
     public Processor(DbContext context, IParser parser, ILogger logger) 
     { 
      _context = context; 
      _parser = parser; 
      _logger = logger; 
     } 
    } 

    public class Parser : IParser 
    { 
     private readonly DbContext _context; 
     private readonly ILogger _logger; 

     //Dependency context passed in is the same object within the scope. See [1] 
     public Parser(DbContext context, ILogger logger) 
     { 
      _context = context; 
      _logger = logger; 
     } 
    } 

    public class Logger : ILogger 
    { 
     private readonly DbContext _context; 

     //Dependency context passed in is the same object within the scope. See [1] 
     public Logger(DbContext context) 
     { 
      _context = context; 
     } 
    } 

    public interface IProcessor 
    { 
    } 

    public interface IParser 
    { 
    } 

    public interface ILogger 
    { 
    } 
} 

Answer 1

您需要查看范围;目前你没有指定一个范围，所以所有的依赖都是单例。 注册DBContext以及​​,IParser和IProcessor所有与Scoped生命。例如。

container.Register(Component.For<DBContext>() 
    .ImplementedBy<DBContext>() 
    .Lifestyle.Scoped); 

然后，您需要解决您的依赖关系并在范围内使用它们。这通常对基础设施进行管理，但在其最简单的是这样的：

using(container.BeginScope()) 
{ 
    var processor = container.Resolve<IProcessor>(); 
    // use processor here. 
} 

现在，一个新DBContext将每个范围创建和配置当容器范围结束。您不必担心初始化DBContext或将其传递给Resolve方法。