autofac使用总结

时间 2019-12-15

标签 autofac 使用总结繁體版

原文原文链接

转摘自：http://niuyi.github.io/blog/2012/04/06/autofac-by-unit-test/git

注册部分：github

AutoFac是.net平台下的IOC容器产品，它能够管理类之间的复杂的依赖关系。在使用方面主要是register和resolve两类操做。这篇文章用单元测试的形式列举了AutoFac的经常使用使用方法：c#

注册部分

使用RegisterType进行注册函数

 
      [Fact]  public void can_resolve_myclass()  {  var builder = new ContainerBuilder();  builder.RegisterType<MyClass>();   IContainer container = builder.Build();  var myClass = container.Resolve<MyClass>();  Assert.NotNull(myClass);  }

注册为接口单元测试

 
      [Fact]  public void register_as_interface()  {  var builder = new ContainerBuilder();  builder.Register(c => new MyClass()).As<MyInterface>();   IContainer container = builder.Build();  Assert.NotNull(container.Resolve<MyInterface>());  Assert.Throws(typeof (ComponentNotRegisteredException), () => container.Resolve<MyClass>());  }

使用lambda表达式进行注册测试

 
      [Fact]  public void can_register_with_lambda()  {  var builder = new ContainerBuilder();  builder.Register(c => new MyClass());   IContainer container = builder.Build();  var myClass = container.Resolve<MyClass>();  Assert.NotNull(myClass);  }

带构造参数的注册ui

 
      [Fact]  public void register_with_parameter()  {  var builder = new ContainerBuilder();  builder.Register(c => new MyParameter());  builder.Register(c => new MyClass(c.Resolve<MyParameter>()));  IContainer container = builder.Build();  Assert.NotNull(container.Resolve<MyClass>());  }

带属性赋值的注册this

 
      [Fact]  public void register_with_property()  {  var builder = new ContainerBuilder();  builder.Register(c => new MyProperty());  builder.Register(  c => new MyClass()  {  Property = c.Resolve<MyProperty>()  });  IContainer container = builder.Build();  var myClass = container.Resolve<MyClass>();  Assert.NotNull(myClass);  Assert.NotNull(myClass.Property);  }

Autofac分离了类的建立和使用，这样能够根据输入参数（NamedParameter）动态的选择实现类。spa

 
      [Fact]  public void select_an_implementer_based_on_parameter_value()  {  var builder = new ContainerBuilder();  builder.Register<IRepository>((c, p) =>  {  var type = p.Named<string>("type");  if (type == "test")  {  return new TestRepository();  }  else  {  return new DbRepository();  }  }).As<IRepository>();   IContainer container = builder.Build();  var repository = container.Resolve<IRepository>(new NamedParameter("type", "test"));  Assert.Equal(typeof(TestRepository),repository.GetType());  }

AufoFac也能够用一个实例来注册，好比用在单例模式状况下：.net

 
      [Fact]  public void register_with_instance()  {  var builder = new ContainerBuilder();  builder.RegisterInstance(MyInstance.Instance).ExternallyOwned();  IContainer container = builder.Build();  var myInstance1 = container.Resolve<MyInstance>();  var myInstance2 = container.Resolve<MyInstance>();  Assert.Equal(myInstance1,myInstance2);  }

注册open generic类型

 
      [Fact]  public void register_open_generic()  {  var builder = new ContainerBuilder();  builder.RegisterGeneric(typeof (MyList<>));  IContainer container = builder.Build();  var myIntList = container.Resolve<MyList<int>>();  Assert.NotNull(myIntList);  var myStringList = container.Resolve<MyList<string>>();  Assert.NotNull(myStringList);  }

对于同一个接口，后面注册的实现会覆盖以前的实现

 
      [Fact]  public void register_order()  {  var containerBuilder = new ContainerBuilder();  containerBuilder.RegisterType<DbRepository>().As<IRepository>();  containerBuilder.RegisterType<TestRepository>().As<IRepository>();   IContainer container = containerBuilder.Build();  var repository = container.Resolve<IRepository>();  Assert.Equal(typeof(TestRepository), repository.GetType());  }

若是不想覆盖的话，能够用PreserveExistingDefaults，这样会保留原来注册的实现。

 
      [Fact]  public void register_order_defaults()  {  var containerBuilder = new ContainerBuilder();  containerBuilder.RegisterType<DbRepository>().As<IRepository>();  containerBuilder.RegisterType<TestRepository>().As<IRepository>().PreserveExistingDefaults();   IContainer container = containerBuilder.Build();  var repository = container.Resolve<IRepository>();  Assert.Equal(typeof (DbRepository), repository.GetType());  }

能够用Name来区分不一样的实现，代替As方法

 
      [Fact]  public void register_with_name()  {  var containerBuilder = new ContainerBuilder();  containerBuilder.RegisterType<DbRepository>().Named<IRepository>("DB");  containerBuilder.RegisterType<TestRepository>().Named<IRepository>("Test");   IContainer container = containerBuilder.Build();  var dbRepository = container.ResolveNamed<IRepository>("DB");  var testRepository = container.ResolveNamed<IRepository>("Test");  Assert.Equal(typeof(DbRepository), dbRepository.GetType());  Assert.Equal(typeof(TestRepository), testRepository.GetType());  }

若是一个类有多个构造函数的话，能够在注册时候选择不一样的构造函数

 
      [Fact]  public void choose_constructors()  {  var builder = new ContainerBuilder();  builder.RegisterType<MyParameter>();  builder.RegisterType<MyClass>().UsingConstructor(typeof (MyParameter));  IContainer container = builder.Build();  var myClass = container.Resolve<MyClass>();  Assert.NotNull(myClass);  }

AutoFac能够注册一个Assemble下全部的类，固然，也能够根据类型进行筛选

1
2 3 4 5 6 7 8 9 10 11 12



 [Fact]  public void register_assembly()  {  var builder = new ContainerBuilder();  builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly()).  Where(t => t.Name.EndsWith("Repository")).  AsImplementedInterfaces();   IContainer container = builder.Build();  var repository = container.Resolve<IRepository>();  Assert.NotNull(repository);  }

事件

AutoFac支持三种事件：OnActivating，OnActivated，OnRelease。OnActivating在注册组件使用以前会被调用，此时能够替换实现类或者进行一些其余的初始化工做，OnActivated在实例化以后会被调用，OnRelease在组件释放以后会被调用。

 
       public class MyEvent : IDisposable  {  public MyEvent(string input)  {  Console.WriteLine(input);  }   public MyEvent()  {  Console.WriteLine("Init");  }   public void Dispose()  {  Console.WriteLine("Dispose");  }  }

 
       public void test_event()  {  var builder = new ContainerBuilder();  builder.RegisterType<MyEvent>().  OnActivating(e => e.ReplaceInstance(new MyEvent("input"))).  OnActivated(e => Console.WriteLine("OnActivated")).  OnRelease(e => Console.WriteLine("OnRelease"));    using (IContainer container = builder.Build())  {  using (var myEvent = container.Resolve<MyEvent>())  {  }  }  }

此时的输出为：

 
      Init input OnActivated Dispose OnRelease

利用事件能够在构造对象以后调用对象的方法：

 
       [Fact]  public void call_method_when_init()  {  var builder = new ContainerBuilder();  builder.RegisterType<MyClassWithMethod>().OnActivating(e => e.Instance.Add(5));  IContainer container = builder.Build();  Assert.Equal(5, container.Resolve<MyClassWithMethod>().Index);  }  public class MyClassWithMethod  {  public int Index { get; set; }  public void Add(int value)  {  Index = Index + value;  }  }

循环依赖

循环依赖是个比较头疼的问题，在AutoFac中不少循环依赖的场景不被支持：

 
       public class ClassA  {  private readonly ClassB b;   public ClassA(ClassB b)  {  this.b = b;  }  }   public class ClassB  {  public ClassA A { get; set; }   }   [Fact]  public void circular_dependencies_exception()  {  var builder = new ContainerBuilder();  builder.Register(c => new ClassB(){A = c.Resolve<ClassA>()});  builder.Register(c => new ClassA(c.Resolve<ClassB>()));  IContainer container = builder.Build();  Assert.Throws(typeof(DependencyResolutionException), ()=>container.Resolve<ClassA>());  }

能够部分的解决这种循环依赖的问题，前提是ClassA和ClassB的生命周期不能都是InstancePerDependency

 
       [Fact]  public void circular_dependencies_ok()  {  var builder = new ContainerBuilder();  builder.RegisterType<ClassB>().  PropertiesAutowired(PropertyWiringFlags.AllowCircularDependencies).SingleInstance();  builder.Register(c => new ClassA(c.Resolve<ClassB>()));  IContainer container = builder.Build();  Assert.NotNull(container.Resolve<ClassA>());  Assert.NotNull(container.Resolve<ClassB>());  Assert.NotNull(container.Resolve<ClassB>().A);  }

生命周期

AutoFac中的生命周期概念很是重要，AutoFac也提供了强大的生命周期管理的能力。

AutoFac定义了三种生命周期：

Per Dependency
Single Instance
Per Lifetime Scope

Per Dependency为默认的生命周期，也被称为’transient’或’factory’，其实就是每次请求都建立一个新的对象

 
       [Fact]  public void per_dependency()  {  var builder = new ContainerBuilder();  builder.RegisterType<MyClass>().InstancePerDependency();  IContainer container = builder.Build();  var myClass1 = container.Resolve<MyClass>();  var myClass2 = container.Resolve<MyClass>();  Assert.NotEqual(myClass1,myClass2);  }

Single Instance也很好理解，就是每次都用同一个对象

 
       [Fact]  public void single_instance()  {  var builder = new ContainerBuilder();  builder.RegisterType<MyClass>().SingleInstance();   IContainer container = builder.Build();  var myClass1 = container.Resolve<MyClass>();  var myClass2 = container.Resolve<MyClass>();   Assert.Equal(myClass1,myClass2);  }

Per Lifetime Scope，同一个Lifetime生成的对象是同一个实例

 
       [Fact]  public void per_lifetime_scope()  {  var builder = new ContainerBuilder();  builder.RegisterType<MyClass>().InstancePerLifetimeScope();   IContainer container = builder.Build();  var myClass1 = container.Resolve<MyClass>();  var myClass2 = container.Resolve<MyClass>();   ILifetimeScope inner = container.BeginLifetimeScope();  var myClass3 = inner.Resolve<MyClass>();  var myClass4 = inner.Resolve<MyClass>();   Assert.Equal(myClass1,myClass2);  Assert.NotEqual(myClass2,myClass3);  Assert.Equal(myClass3,myClass4);  }

 
       [Fact]  public void life_time_and_dispose()  {  var builder = new ContainerBuilder();  builder.RegisterType<Disposable>();   using (IContainer container = builder.Build())  {  var outInstance = container.Resolve<Disposable>(new NamedParameter("name", "out"));   using(var inner = container.BeginLifetimeScope())  {  var inInstance = container.Resolve<Disposable>(new NamedParameter("name", "in"));  }//inInstance dispose here  }//out dispose here  }