【中间件】AutoFac 理解和使用

一、标准的三层架构模式

Blog.AutoFac.ConsoleApp：控制台应用程序代替界面层（UI），负责处理数据；    
Blog.AutoFac.Service：业务逻辑层（BLL），负责业务逻辑运算；    
Blog.AutoFac.Repository：数据访问层（DAL），负责提供数据。

BlogService 在构造函数初始化 BlogRepository 对象，BlogService 实现依赖于 BlogRepository。BlogRepository 的代码改动也会导致 BlogService 代码改动，这是一种紧密耦合关系。

数据访问层代码：

    /// <summary>
    /// 博客仓储
    /// </summary>
    public class BlogRepository
    {
        public string GetBlogName(long BlogId)
        {
            return "Autofac入门到入坟";
        }
    }

业务层代码：

    public class BlogService
    {
        readonly BlogRepository _blogRepository;
        public BlogService()
        {
            _blogRepository= new BlogRepository();
        }

        public string GetBlogName(long BlogId)
        { 
            return _blogRepository.GetBlogName(BlogId);
        }
    }

 二、面向接口

• 面向接口编程是面向对象编程的一部分，通过定义一组接口，仅向上层暴露其接口功能，上层对于下层仅仅是接口依赖，而不依赖具体类。
• 面向接口好处是降低程序的耦合性，相对于标准的三层架构模式，解除BlogService 对于 BlogRepository 的依赖，易于程序的扩展。
• 面向接口编程遵循设计模式的开闭原则（对扩展开放，对修改关闭），将具体逻辑与实现分开，有新的改动可以添加新类，减少对于其他模块的影响。

Blog.AutoFac.ConsoleApp：界面层（UI），负责展示数据；    
Blog.AutoFac.Service：业务逻辑层（BLL），负责业务逻辑运算；    
Blog.AutoFac.Repository：数据访问层（DAL），负责提供数据；
Blog.AutoFac.IService：业务逻辑抽象层（InterfaceBLL），业务逻辑运算抽象接口；
Blog.AutoFac.IRepository：数据访问抽象层（InterfaceDAL），数据访问抽象接口。

添加数据访问抽象层接口：

    public interface IBlogRepository
    {
        string GetBlogName(long BlogId);
    }

 然后让 BlogRepository 去实现这个接口：

    /// <summary>
    /// 博客仓储
    /// </summary>
    public class BlogRepository: IBlogRepository
    {
        public string GetBlogName(long BlogId)
        {
            return "Autofac入门到入坟";
        }
    }

添加业务逻辑抽象层接口：

    public interface IBlogService
    {
        string GetBlogName(long BlogId);
    }

BlogService 只依赖于 IBlogRepository，后续增删改查可以通过  IBlogRepository 这个抽象来定义：

    public class BlogService: IBlogService
    {
        readonly IBlogRepository _blogRepository;
        public BlogService()
        {
            _blogRepository= new BlogRepository();
        }

        public string GetBlogName(long BlogId)
        { 
            return _blogRepository.GetBlogName(BlogId);
        }
    }

三、控制反转

• 如果项目业务有多个 Service，当 Service 要使用 Repository，Service 除了自身主要业务职责还得创建仓储类实例（控制关系）。
• 那么有木有一种方法可以让 Repository 注入到 Service 里来，使得 Service 不需要关注Repository 实例，降低代码之间的耦合度？
• 我们可以使用控制反转（Inversion of Control，缩写为IoC）设计原则解决上述问题，通过依赖注入（Dependency Injection，缩写DI）实现IOC。
•  这里通过引入开源的轻量级的 DI 容器 AutoFac ，把会产生依赖的对象添加到容器当中，把对象创建实例的权限交给容器，当BlogService内部需要使用 BlogRepository 时，是通过容器，把 BlogRepository 注入到 BlogService 当中。

Blog.AutoFac.ConsoleApp：界面层（UI），负责展示数据；    
Blog.AutoFac.Service：业务逻辑层（BLL），负责业务逻辑运算；    
Blog.AutoFac.Repository：数据访问层（DAL），负责提供数据；
Blog.AutoFac.IService：业务逻辑抽象层（InterfaceBLL），业务逻辑运算抽象接口；
Blog.AutoFac.IRepository：数据访问抽象层（InterfaceDAL），数据访问抽象接口；
Blog.AutoFac.Ioc：控制反转，依赖注入的处理类。

通过 NuGet 包管理器安装 Autofac:

BlogService 类通过构造函数注入 BlogRepository 实例。

    public class BlogService: IBlogService
    {
        readonly IBlogRepository _blogRepository;
        public BlogService(IBlogRepository blogRepository)
        {
            _blogRepository = blogRepository;
        }

        public string GetBlogName(long BlogId)
        { 
            return _blogRepository.GetBlogName(BlogId);
        }
    }

DIContainer 依赖注入类：

    /// <summary>
    /// 控制台程序容器
    /// </summary>
    public static class DIContainer
    {
        /// <summary>
        /// 容器
        /// </summary>
        public static IContainer Instance;

        /// <summary>
        /// 初始化容器
        /// </summary>
        /// <returns></returns>
        public static void Init()
        {
            //新建容器构建器，用于注册组件和服务
            var builder = new ContainerBuilder();
            //自定义注册
            BuildrRegister(builder);
            //利用构建器创建容器
            Instance = builder.Build();
        }

        /// <summary>
        /// 自定义注册
        /// </summary>
        /// <param name="builder"></param>
        public static void BuildrRegister(ContainerBuilder builder)
        {
            builder.RegisterType<BlogRepository>().As<IBlogRepository>();
            builder.RegisterType<BlogService>().As<IBlogService>();
        }

在控制台应用程序使用：

    internal class Program
    {
        static void Main(string[] args)
        {
            // 初始化容器，将需要用到的组件添加到容器中
            DIContainer.Init();

            // 获取博客名称
            IBlogService blogService = DIContainer.Instance.Resolve<IBlogService>();
            string blogName =  blogService.GetBlogName(1);
            Console.WriteLine(blogName);
            Console.ReadLine();
        }
    }

代码示例

四、Autofac 注册方式

4.1 实例注册

使用RegisterInstance把实例注册到容器有两种：
注册一个对象实例：

            // 实例注册
            var blogRepository = new BlogRepository();
            builder.RegisterInstance(blogRepository).As<BlogRepository>();

注册已存在单例：

    internal class Singleton
    {
        private static Singleton instance = null;
        static Singleton() { }

        private static object objectlock = new object();

        public static Singleton Instance
        {
            get
            {
                lock (objectlock)
                {
                    if (instance == null)
                    {
                        instance = new Singleton();
                    }
                    return instance;
                }
            }
        }
    }

builder.RegisterInstance(Singleton.Instance).ExternallyOwned();

4.2 反射注册

使用RegisterType<T>()或者RegisterType(typeof(T))方法，注入对象与暴露类型：

            builder.RegisterType<BlogRepository>().As<IBlogRepository>();
            builder.RegisterType<BlogService>().As(typeof(IBlogService));

4.3 泛型注册

 使用泛型注册对仓储层的类注入：

            builder.RegisterGeneric(typeof(BaseRepository<>))
                    .As(typeof(IBaseRepository<>)).InstancePerLifetimeScope();

4.4 程序集批量注册

            var assemblies = Assembly.GetExecutingAssembly();

            builder.RegisterAssemblyTypes(assemblies)
                .Where(cc => cc.Name.EndsWith("Repository") | cc.Name.EndsWith("Service"))
                .PublicOnly() // 只要public访问权限的
                .Where(cc => cc.IsClass) // 只要class型
                .AsImplementedInterfaces(); // 所有接口类型暴露

            builder.RegisterGeneric(typeof(BaseRepository<>)).As(typeof(IBaseRepository<>));