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     {
         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 = )
         {
             try
             {
                 if (entities == null)
                     throw new ArgumentNullException("entities");
                 if (entities.HasItems())
                 {
                     if (batchSize <= )
                     {
                         entities.Each(x => this.Entities.Add(x));
                         if (this.AutoCommitEnabled)
                             _context.SaveChanges();
                     }
                     else
                     {
                         int i = ;
                         bool saved = false;
                         foreach (var entity in entities)
                         {
                             this.Entities.Add(entity);
                             saved = false;
                             if (i % batchSize == )
                             {
                                 if (this.AutoCommitEnabled)
                                     _context.SaveChanges();
                                 i = ;
                                 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();