AutoFac初探

.net 4.0使用的DLL

 #region RegisterType注册
          
            var builder = new ContainerBuilder();
            builder.RegisterType<DatabaseManager>();
            builder.RegisterType<SqlDatabase>().As<IDatabase>();//通过AS可以让DatabaseManager类中通过构造函数依赖注入类型相应的接口。
            using (var container = builder.Build())
            {
                // var sqlIntance = container.Resolve<SqlDatabase>(); 【报错：】使用As方法会将原件默认的服务覆盖掉，所以无法用这种方式取得对象
                var sqlIntance = container.Resolve<IDatabase>();

                var manager = container.Resolve<DatabaseManager>();
                manager.Search("Select * from User");
            }
           
            
            #endregion

            #region 属性注入
            /*
             * 属性注入

            这是推荐的属性初始化方式. IComponentContext.ResolveOptional() 很方便:
             * 
            builder.Register(c => new A(){ MyB = c.ResolveOptional<B>() }); 
             * 
            或者, PropertiesAutowired() 这个方法也可以导致属性注入.
             * 
            builder.RegisterType<X>().PropertiesAutowired(); 
             */
            #endregion

            #region 配置文件进行注册
            //var builder = new ContainerBuilder();
            //builder.RegisterType<DatabaseManager>();           
            //builder.RegisterModule(new ConfigurationSettingsReader("autofac"));           
            //using (var container = builder.Build())
            //{
            //    var manager = container.Resolve<DatabaseManager>();
            //    manager.Search("Select * form user");
            //}
            /*
             * 这里通过ContainerBuilder方法RegisterType对DatabaseManager进行注册，当注册的类型在相应得到的容器中可以Resolve你的DatabaseManager实例。

                builder.RegisterType<SqlDatabase>().As<IDatabase>();通过AS可以让DatabaseManager类中通过构造函数依赖注入类型相应的接口。

                Build()方法生成一个对应的Container实例，这样，就可以通过Resolve解析到注册的类型实例。
             
             */
            #endregion

            #region 通过Register方法进行注册
            //var builder = new ContainerBuilder();
            //builder.RegisterModule(new ConfigurationSettingsReader("autofac"));
            //builder.Register(c => new DatabaseManager(c.Resolve<IDatabase>())); //构造函数注入，c是创建元件的容器
            //using (var container = builder.Build())
            //{
            //    var manager = container.Resolve<DatabaseManager>();
            //    manager.Search("Select * from User");
            //}
            #endregion


            #region MyRegion
            //User user = new User { Id = 1, Name = "leepy" };
            //var builder = new ContainerBuilder();
            //builder.RegisterModule(new ConfigurationSettingsReader("autofac"));
            //builder.RegisterInstance(user).As<User>(); //已经存在的实例user,这时就不能再创造对象而是应该在容器中将它注册为实例，这种方法会确保系统中的单例实例最终转化为由容器托管的单例实例.
            //builder.Register(c => new DatabaseManager(c.Resolve<IDatabase>(), c.Resolve<User>()));

            //using (var container = builder.Build())
            //{
            //    var manager = container.Resolve<DatabaseManager>();

            //    manager.Add("INSERT INTO USER ...");
            //} 
            #endregion

            #region 开放的泛型类型
            /*
             * 开放的泛型类型

                autofac支持开放的泛型类型.使用 RegisterGeneric() 这个方法:

                builder.RegisterGeneric(typeof(NHibernateRepository<>))

                   .As(typeof(IRepository<>))

                   .InstancePerLifetimeScope(); 


                当从容器中请求一个匹配的类型时,autofac会自动匹配一个等价的具体实现类型.

                // Autofac will return an NHibernateRepository<Task>

                var tasks = container.Resolve<IRepository<Task>>(); 


                注册一个具体的类型((e.g. IRepository<Person> )会覆盖掉上面的泛型注册.

             */
            #endregion

            #region 【扫描组件】
            var dataAccess = Assembly.GetExecutingAssembly();
            builder.RegisterAssemblyTypes(dataAccess).Where(t => t.Name.EndsWith("Repository")).AsImplementedInterfaces();
            //每个RegisterAssemblyTypes方法只能应用一套规则。如果有多套不同的集合要注册，那就有必要多次调用RegisterAssemblyTypes。


            /*
             * 选择类型
                RegisterAssemblyTypes接受程序集的集合。默认情况下，程序集中所有公共具体的类都会被注册。
                如果想要过滤注册的类型，可以使用Where.向下面这样：

                Where(t => t.Name.EndsWith("Repository"))
                如果想要排除某些类型，使用Except（）：

                Except<MyUnwantedType>()
                或者，自定义那些已经排除的类型的注册：

                Except<MyCustomisedType>(ct =>ct.As<ISpecial>().SingleInstance())
                多个过滤器可以同时使用，这时他们之间是AND的关系
             * 
             * 
             * RegisterAssemblyTypes这个注册方法是注册单个方法的超集，所以类似As的方法也可以用在程序集中，例如
                As<IRepository>()
                As和Named这两个方法额外的重载方法接受lambda表达式来决定服务会提供什么样的类型。
             */
            #endregion

            #region 【 Per Dependency】
            /*             
          Per Dependency
        在其他容器中也称作瞬态或者工厂，使用Per Dependency作用域，服务对于每次请求都会返回单独的实例。
        在没有指定其他参数的情况下，这是默认是作用域。
        builder.RegisterType<X>(); 
         or 
        builder.RegisterType<X>().InstancePerDependency();
 
             */
            #endregion

            #region [Single Instance]
            /*
             Single Instance
            使用Single Instance作用域，所有对父容器或者嵌套容器的请求都会返回同一个实例。
            builder.RegisterType<X>().SingleInstance();
            */
            #endregion

View Code

************************************************分割线********************************************************************

            //以IoC依赖注入方式创建对象
            using (var container = RegisterContainer())
            {    
                container.Resolve<MemoChecker>().CheckNow();
                Console.ReadKey();
            }

View Code