Autofac3 在MVC4中的运用原理

    这是一种新的开发模式，注入开发模式，或者叫它IOC模式，说起IOC你可以这样去理解它，它为你的某个实现流出一个注入点，你生产的对象，可以根据你之前的配置进行组合。  IOC全称是Inversion of Control，即反转控制,或者说是依赖注入更为合适。选择别纠结这些全称的专业词。我们可以用别外一些方式去理解它，IOC，是一种设计模式。它的延生所要实现的是把藕合从代码中移出去，统一放到XML文件中，通过一个容器在需要的时候把这个依赖关系形成，即把需要的接口实现注入到需要它的类中，这可能就是“依赖注入”说法的来源了。 

而注入点的位置及方式也是多种多样的，我们今天主要说一个通过HTTP请求进行注入的方式，IOC工具使用高效的Autofac,对它的认识你可以看这篇文章。

首先看一下我们这个项目的知识点：
MVC4一个对UI层进行分层的架构模式，在微软的MVC4中加入了开源的Razor引擎
EF（Entity Framework）这无疑是微软自己比较成功的ORM（Object Relational Mapping）工具（即对象关系映射,目前数据库是关系型数据库ORM 主要是把数据库中的关系数据映射称为程序中的对象），它执行效率上要高于linq to sql，甚至你自己编写的ado.net脚本。
Autofac这是在orchard项目中被广泛的IOC工具，它支持类型，反泛，HTTP等注入
对于这个系统的autofac部分，我们将它的注入点放在controller的构造函数中，将生产的对象配置在global中，当然，你也可以设置在config文件，或者你自己的文件中。
我认为它的工作方式应该是：
网站启动=>从global中得到ioc配置信息=>http request请求页面=>通过controller中的参数进行实现的创建=>action中使用创建好的对象

OK，有了这样一个理论基础，我们来看一下代码吧：

EF部分的DATA层

 public partial class EfRepository<T> : IRepository<T> where T : class  2     {
        private readonly Guid _instanceId;
        private readonly IDbContext _context;
        private IDbSet<T> _entities;
        public Guid InstanceId
        {
            get { return _instanceId; }
        }
        public EfRepository(IDbContext context)
        {
            AutoCommitEnabled = true;
            this._context = context;
            _instanceId = Guid.NewGuid();
        }
        public T GetById(object id)
        {
            return this._entities.Find(id);
        }
        public T Create()
        {
            return this.Entities.Create();
        }
        public void Insert(T entity)
        {
            try
            {
                if (entity == null)
                    throw new ArgumentNullException("entity");
                this.Entities.Add(entity);
                if (this.AutoCommitEnabled)
                    _context.SaveChanges();
            }
            catch(DbEntityValidationException dbEx)
            {
                var msg = string.Empty;
                foreach(var validationErrors in dbEx.EntityValidationErrors)
                    foreach (var validationError in validationErrors.ValidationErrors)
                        msg += string.Format("Property: {0} Error: {1}", validationError.PropertyName, validationError.ErrorMessage) + Environment.NewLine;
                var fail = new Exception(msg, dbEx);
                throw fail;
            }
        }

        public void InsertRange(IEnumerable<T> entities, int batchSize = 100)
        {
            try
            {
                if (entities == null)
                    throw new ArgumentNullException("entities");
                if (entities.HasItems())
                {
                    if (batchSize <= 0)
                    {
                        entities.Each(x => this.Entities.Add(x));
                        if (this.AutoCommitEnabled)
                            _context.SaveChanges();
                    }
                    else
                    {
                        int i = 1;
                        bool saved = false;
                        foreach (var entity in entities)
                        {
                            this.Entities.Add(entity);
                            saved = false;
                            if (i % batchSize == 0)
                            {
                                if (this.AutoCommitEnabled)
                                    _context.SaveChanges();
                                i = 0;
                                saved = true;
                            }
                            i++;
                        }
                        if (!saved)
                        {
                            if (this.AutoCommitEnabled)
                                _context.SaveChanges();
                        }
                    }
                }
            }
            catch (DbEntityValidationException ex)
            {
                throw ex;
            }
        }
        public void Update(T entity)
        {
            if (entity == null)
                throw new ArgumentNullException("entity");
            try
            {
                if (this.InternalContext.Entry(entity).State == EntityState.Detached)
                {
                    var set = Entities;
                    T attachedEntity = set.Find(entity.Key);  // You need to have access to key

                    if (attachedEntity != null)
                    {
                        var attachedEntry = this.InternalContext.Entry(attachedEntity);
                        attachedEntry.CurrentValues.SetValues(entity);
                    }
                    else
                    {
                        // This should attach entity
                        this.InternalContext.Entry(entity).State = EntityState.Modified;
                    }
                }
            }
            finally { }

            if (AutoCommitEnabled)
                _context.SaveChanges();
        }

        public void Delete(T entity)
        {
            if (entity == null)
                throw new ArgumentNullException("entity");
            if(InternalContext.Entry(entity).State==EntityState.Detached)
            {
                this.Entities.Attach(entity);
            }
            this.Entities.Remove(entity);
            if (this.AutoCommitEnabled)
                _context.SaveChanges();
        }

        public IDictionary<string, object> GetModifiedProperties(T entity)
        {
            var props = new Dictionary<string, object>();

            var ctx = InternalContext;
            var entry = ctx.Entry(entity);
            var modifiedPropertyNames = from p in entry.CurrentValues.PropertyNames
                                        where entry.Property(p).IsModified
                                        select p;
            foreach (var name in modifiedPropertyNames)
            {
                props.Add(name, entry.Property(name).OriginalValue);
            }

            return props;
        }
        public virtual IQueryable<T> Table
        {
            get
            {
                return this.Entities;
            }
        }

        public int Commit()
        {
            try
            {
                return this._context.SaveChanges();
            }
            catch(DbEntityValidationException dbEx)
            {
                var msg = string.Empty;
                foreach (var validationErrors in dbEx.EntityValidationErrors)
                    foreach (var validationError in validationErrors.ValidationErrors)
                        msg += Environment.NewLine + string.Format("Property: {0} Error: {1}", validationError.PropertyName, validationError.ErrorMessage);

                var fail = new Exception(msg, dbEx);
                throw fail;
            }
        }
        #region Helpers
        protected internal dwDbContextBase InternalContext
        {
            get { return _context as dwDbContextBase; }
        }
        public bool AutoCommitEnabled { get; set; }

        private DbSet<T> Entities
        {
            get
            {
                if (_entities == null) { _entities = _context.Set<T>(); }
                return _entities as DbSet<T>;
            }
        }

        #endregion

        public IQueryable<T> Include(IQueryable<T> query,string path)
        {
            Guard.ArgumentNotNull(query, "query");
            Guard.ArgumentNotEmpty(path, "path");
            return query.Include(path);
        }
        public IQueryable<T> Include<TProperty>(IQueryable<T> query,Expression<Func<T,TProperty>> path)
        {
            Guard.ArgumentNotNull(query, "query");
            Guard.ArgumentNotNull(path, "path");
            return query.Include(path);
        }
        public IDbContext Context
        {
            get { return _context; }
        }

    }

 Services层（BLL层）核心代码：

  public class TestService : BaseService, ITestService
    {
        private const string IncludeProperties = "";
        private readonly IRepository<Tests> _repository;
        private readonly ICacheManager _cacheManager;
        private readonly IExporter _exporter;
        public IList<Tests> GetAll()
        {
            return _repository.FindBy(null, null, IncludeProperties).ToList();
        }

        public TestService(IRepository<Tests> repository,
            ICacheManager cacheManager,IExporter exporter,
            IEventPublisher eventPublisher):base(eventPublisher)
        {
            _repository = repository;
            _exporter = exporter;
            _cacheManager = cacheManager;
        }

    }

WEB层MVC部分代码：(注意：我们的WEB层不应该有对DATA层的引用，WEB层一般只注入SERVICE的对象，这一点是需要注意的，即不要直接调用数据库仓库）

 public class TestController : ApiController
    {
        private readonly ITestService _service;
        private readonly Func<Tests, TestsModel, TestsModel> _convertCallback = (entity, model) => { return model; };
        public TestController(ITestService service) { _service = service; }
        public IEnumerable<TestsModel> Get()
        {
            var items = _service.GetAll();
            var model = items.ConvertTo(_convertCallback);
            return model;
        }

而注入参数我们放在global中，看一下核心代码：

            //初始化依赖注入组件
            var bootStrapper = new AutofacBootStrapper();
            BootStrapperManager.Initialize(bootStrapper);
            //设置依赖注入
            GlobalConfiguration.Configuration.DependencyResolver = bootStrapper.GetWebApiDependencyResolver();
            DependencyResolver.SetResolver(bootStrapper.GetMvcDependencyResolver());

 builder.Register(c => new dwObjectContext("MyConnection")).As<IDbContext>().InstancePerHttpRequest().InstancePerApiRequest();
            builder.RegisterGeneric(typeof(EfRepository<>)).As(typeof(IRepository<>)).InstancePerHttpRequest().InstancePerApiRequest();

            //注册缓存类型
            builder.RegisterType<StaticCache>().As<ICache>().Named<ICache>(YB_CACHE_STATIC).SingleInstance();
            builder.RegisterType<RequestCache>().As<ICache>().Named<ICache>(YB_CACHE_PER_REQUEST).InstancePerHttpRequest().InstancePerApiRequest();
            //注册缓存控制类型
            builder.RegisterType<NullCacheManager>()
                .As<ICacheManager>()
                .Named<ICacheManager>(YB_SM_CACHE_NULL)
                .WithParameter(ResolvedParameter.ForNamed<ICache>(YB_CACHE_STATIC))
                .SingleInstance();

            builder.RegisterType<DefaultCacheManager>()
                .As<ICacheManager>()
                .Named<ICacheManager>(YB_SM_CACHE_PER_REQUEST)
                .WithParameter(ResolvedParameter.ForNamed<ICache>(YB_CACHE_PER_REQUEST))
                .InstancePerHttpRequest().InstancePerApiRequest();

            builder.RegisterType<DefaultCacheManager>()
               .As<ICacheManager>()
                //.Named<ICacheManager>(YB_SM_CACHE_STATIC)
               .WithParameter(ResolvedParameter.ForNamed<ICache>(YB_CACHE_STATIC))
               .SingleInstance();

            var assembly = Assembly.GetExecutingAssembly();
            //注册所有 MVC 控制器
            builder.RegisterControllers(assembly)
                .InstancePerHttpRequest();
            //注册所有 Web Api 控制器
            builder.RegisterApiControllers(assembly)
                .InstancePerApiRequest();