Orchard详解--第三篇 依赖注入之基础设施

　　Orchard提供了依赖注入机制，并且框架的实现也离不开依赖注入如模块管理、日志、事件等。在前一篇中提到在Global.asax中定义的HostInitialization创建了Autofac的IoC容器。

      private static IOrchardHost HostInitialization(HttpApplication application) {
            var host = OrchardStarter.CreateHost(MvcSingletons);
 
            host.Initialize();
 
            // initialize shells to speed up the first dynamic query
            host.BeginRequest();
            host.EndRequest();
 
            return host;
        }    

其中OrchardStarter是位于Orchard.Framework项目中Environment目录下的类型

    public static IOrchardHost CreateHost(Action<ContainerBuilder> registrations) {
            var container = CreateHostContainer(registrations);
            return container.Resolve<IOrchardHost>();
        }

以下是容器创建的全量代码：

        public static IContainer CreateHostContainer(Action<ContainerBuilder> registrations) {
            ExtensionLocations extensionLocations = new ExtensionLocations();
 
            var builder = new ContainerBuilder();
            // Application paths and parameters
            builder.RegisterInstance(extensionLocations);
 
            builder.RegisterModule(new CollectionOrderModule());
            builder.RegisterModule(new LoggingModule());
            builder.RegisterModule(new EventsModule());
            builder.RegisterModule(new CacheModule());
 
            // a single default host implementation is needed for bootstrapping a web app domain
            builder.RegisterType<DefaultOrchardEventBus>().As<IEventBus>().SingleInstance();
            builder.RegisterType<DefaultCacheHolder>().As<ICacheHolder>().SingleInstance();
            builder.RegisterType<DefaultCacheContextAccessor>().As<ICacheContextAccessor>().SingleInstance();
            builder.RegisterType<DefaultParallelCacheContext>().As<IParallelCacheContext>().SingleInstance();
            builder.RegisterType<DefaultAsyncTokenProvider>().As<IAsyncTokenProvider>().SingleInstance();
            builder.RegisterType<DefaultHostEnvironment>().As<IHostEnvironment>().SingleInstance();
            builder.RegisterType<DefaultHostLocalRestart>().As<IHostLocalRestart>().Named<IEventHandler>(typeof(IShellSettingsManagerEventHandler).Name).SingleInstance();
            builder.RegisterType<DefaultBuildManager>().As<IBuildManager>().SingleInstance();
            builder.RegisterType<DynamicModuleVirtualPathProvider>().As<ICustomVirtualPathProvider>().SingleInstance();
            builder.RegisterType<AppDataFolderRoot>().As<IAppDataFolderRoot>().SingleInstance();
            builder.RegisterType<DefaultExtensionCompiler>().As<IExtensionCompiler>().SingleInstance();
            builder.RegisterType<DefaultRazorCompilationEvents>().As<IRazorCompilationEvents>().SingleInstance();
            builder.RegisterType<DefaultProjectFileParser>().As<IProjectFileParser>().SingleInstance();
            builder.RegisterType<DefaultAssemblyLoader>().As<IAssemblyLoader>().SingleInstance();
            builder.RegisterType<AppDomainAssemblyNameResolver>().As<IAssemblyNameResolver>().SingleInstance();
            builder.RegisterType<GacAssemblyNameResolver>().As<IAssemblyNameResolver>().SingleInstance();
            builder.RegisterType<OrchardFrameworkAssemblyNameResolver>().As<IAssemblyNameResolver>().SingleInstance();
            builder.RegisterType<HttpContextAccessor>().As<IHttpContextAccessor>().InstancePerDependency();
            builder.RegisterType<ViewsBackgroundCompilation>().As<IViewsBackgroundCompilation>().SingleInstance();
            builder.RegisterType<DefaultExceptionPolicy>().As<IExceptionPolicy>().SingleInstance();
            builder.RegisterType<DefaultCriticalErrorProvider>().As<ICriticalErrorProvider>().SingleInstance();
            //builder.RegisterType<RazorTemplateCache>().As<IRazorTemplateProvider>().SingleInstance();
 
            RegisterVolatileProvider<WebSiteFolder, IWebSiteFolder>(builder);
            RegisterVolatileProvider<AppDataFolder, IAppDataFolder>(builder);
            RegisterVolatileProvider<DefaultLockFileManager, ILockFileManager>(builder);
            RegisterVolatileProvider<Clock, IClock>(builder);
            RegisterVolatileProvider<DefaultDependenciesFolder, IDependenciesFolder>(builder);
            RegisterVolatileProvider<DefaultExtensionDependenciesManager, IExtensionDependenciesManager>(builder);
            RegisterVolatileProvider<DefaultAssemblyProbingFolder, IAssemblyProbingFolder>(builder);
            RegisterVolatileProvider<DefaultVirtualPathMonitor, IVirtualPathMonitor>(builder);
            RegisterVolatileProvider<DefaultVirtualPathProvider, IVirtualPathProvider>(builder);
           
            builder.RegisterType<DefaultOrchardHost>().As<IOrchardHost>().As<IEventHandler>()
                .Named<IEventHandler>(typeof(IShellSettingsManagerEventHandler).Name)
                .Named<IEventHandler>(typeof(IShellDescriptorManagerEventHandler).Name)
                .SingleInstance();
            {
                builder.RegisterType<ShellSettingsManager>().As<IShellSettingsManager>().SingleInstance();
 
                builder.RegisterType<ShellContextFactory>().As<IShellContextFactory>().SingleInstance();
                {
                    builder.RegisterType<ShellDescriptorCache>().As<IShellDescriptorCache>().SingleInstance();
 
                    builder.RegisterType<CompositionStrategy>().As<ICompositionStrategy>().SingleInstance();
                    {
                        builder.RegisterType<ShellContainerRegistrations>().As<IShellContainerRegistrations>().SingleInstance();
                        builder.RegisterType<ExtensionLoaderCoordinator>().As<IExtensionLoaderCoordinator>().SingleInstance();
                        builder.RegisterType<ExtensionMonitoringCoordinator>().As<IExtensionMonitoringCoordinator>().SingleInstance();
                        builder.RegisterType<ExtensionManager>().As<IExtensionManager>().SingleInstance();
                        {
                            builder.RegisterType<ExtensionHarvester>().As<IExtensionHarvester>().SingleInstance();
                            builder.RegisterType<ModuleFolders>().As<IExtensionFolders>().SingleInstance()
                                .WithParameter(new NamedParameter("paths", extensionLocations.ModuleLocations));
                            builder.RegisterType<CoreModuleFolders>().As<IExtensionFolders>().SingleInstance()
                                .WithParameter(new NamedParameter("paths", extensionLocations.CoreLocations));
                            builder.RegisterType<ThemeFolders>().As<IExtensionFolders>().SingleInstance()
                                .WithParameter(new NamedParameter("paths", extensionLocations.ThemeLocations));
 
                            builder.RegisterType<CoreExtensionLoader>().As<IExtensionLoader>().SingleInstance();
                            builder.RegisterType<ReferencedExtensionLoader>().As<IExtensionLoader>().SingleInstance();
                            builder.RegisterType<PrecompiledExtensionLoader>().As<IExtensionLoader>().SingleInstance();
                            builder.RegisterType<DynamicExtensionLoader>().As<IExtensionLoader>().SingleInstance();
                            builder.RegisterType<RawThemeExtensionLoader>().As<IExtensionLoader>().SingleInstance();
                        }
                    }
 
                    builder.RegisterType<ShellContainerFactory>().As<IShellContainerFactory>().SingleInstance();
                }
 
                builder.RegisterType<DefaultProcessingEngine>().As<IProcessingEngine>().SingleInstance();
            }
 
            builder.RegisterType<RunningShellTable>().As<IRunningShellTable>().SingleInstance();
            builder.RegisterType<DefaultOrchardShell>().As<IOrchardShell>().InstancePerMatchingLifetimeScope("shell");
            builder.RegisterType<SessionConfigurationCache>().As<ISessionConfigurationCache>().InstancePerMatchingLifetimeScope("shell");
 
            registrations(builder);
 
            var autofacSection = ConfigurationManager.GetSection(ConfigurationSettingsReaderConstants.DefaultSectionName);
            if (autofacSection != null)
                builder.RegisterModule(new ConfigurationSettingsReader());
 
            var optionalHostConfig = HostingEnvironment.MapPath("~/Config/Host.config");
            if (File.Exists(optionalHostConfig))
                builder.RegisterModule(new ConfigurationSettingsReader(ConfigurationSettingsReaderConstants.DefaultSectionName, optionalHostConfig));
 
            var optionalComponentsConfig = HostingEnvironment.MapPath("~/Config/HostComponents.config");
            if (File.Exists(optionalComponentsConfig))
                builder.RegisterModule(new HostComponentsConfigModule(optionalComponentsConfig));
 
            var container = builder.Build();
 
            //
            // Register Virtual Path Providers
            //
            if (HostingEnvironment.IsHosted) {
                foreach (var vpp in container.Resolve<IEnumerable<ICustomVirtualPathProvider>>()) {
                    HostingEnvironment.RegisterVirtualPathProvider(vpp.Instance);
                }
            }
 
            ControllerBuilder.Current.SetControllerFactory(new OrchardControllerFactory());
            FilterProviders.Providers.Add(new OrchardFilterProvider());
 
            GlobalConfiguration.Configuration.Services.Replace(typeof(IHttpControllerSelector), new DefaultOrchardWebApiHttpControllerSelector(GlobalConfiguration.Configuration));
            GlobalConfiguration.Configuration.Services.Replace(typeof(IHttpControllerActivator), new DefaultOrchardWebApiHttpControllerActivator(GlobalConfiguration.Configuration));
            GlobalConfiguration.Configuration.DependencyResolver = new AutofacWebApiDependencyResolver(container);
 
            GlobalConfiguration.Configuration.Filters.Add(new OrchardApiActionFilterDispatcher());
            GlobalConfiguration.Configuration.Filters.Add(new OrchardApiExceptionFilterDispatcher());
            GlobalConfiguration.Configuration.Filters.Add(new OrchardApiAuthorizationFilterDispatcher());
 
            ViewEngines.Engines.Clear();
            ViewEngines.Engines.Add(new ThemeAwareViewEngineShim());
 
            var hostContainer = new DefaultOrchardHostContainer(container);
            //MvcServiceLocator.SetCurrent(hostContainer);
            OrchardHostContainerRegistry.RegisterHostContainer(hostContainer);
 
            // Register localized data annotations
            ModelValidatorProviders.Providers.Clear();
            ModelValidatorProviders.Providers.Add(new LocalizedModelValidatorProvider());
 
            return container;
        }        

代码很长，但是可以分为以下几个部分：

• 基础组件：日志、事件、缓存
• 环境相关：路径、程序集、编译器，Http上下文
• 异常处理：异常策略
• 拓展相关：拓展目录、拓展依赖、拓展管理。
• 多租户相关：Shell表、Shell启动。
• 拓展的依赖注入：拓展模块中的自定义注入、Host及HostComponents配置文件的注入。
• MVC相关：ControllerFactory替换，过滤器加载
• WebAPI相关：Selector、Activator替换，DependencyResolver替换、过滤器加载
• ViewEngine：使用ThemeAwareViewEngineShim。
• Model相关：使用LocalizedModelValidatorProvider作为Model验证器。

 

相对特殊的地方有：

1. 日志的自动属性注入：

Orchard使用Autofac实现了日志的属性自动注入，具体代码如下：

        protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration) {
            var implementationType = registration.Activator.LimitType;
 
            // build an array of actions on this type to assign loggers to member properties
            var injectors = BuildLoggerInjectors(implementationType).ToArray();
 
            // if there are no logger properties, there's no reason to hook the activated event
            if (!injectors.Any())
                return;
 
            // otherwise, whan an instance of this component is activated, inject the loggers on the instance
            registration.Activated += (s, e) => {
                foreach (var injector in injectors)
                    injector(e.Context, e.Instance);
            };
        }
 
        private IEnumerable<Action<IComponentContext, object>> BuildLoggerInjectors(Type componentType) {
            // Look for settable properties of type "ILogger"
            var loggerProperties = componentType
                .GetProperties(BindingFlags.SetProperty | BindingFlags.Public | BindingFlags.Instance)
                .Select(p => new {
                    PropertyInfo = p,
                    p.PropertyType,
                    IndexParameters = p.GetIndexParameters(),
                    Accessors = p.GetAccessors(false)
                })
                .Where(x => x.PropertyType == typeof(ILogger)) // must be a logger
                .Where(x => x.IndexParameters.Count() == 0) // must not be an indexer
                .Where(x => x.Accessors.Length != 1 || x.Accessors[0].ReturnType == typeof(void)); //must have get/set, or only set
 
            // Return an array of actions that resolve a logger and assign the property
            foreach (var entry in loggerProperties) {
                var propertyInfo = entry.PropertyInfo;
 
                yield return (ctx, instance) => {
                    string component = componentType.ToString();
                    if (component != instance.GetType().ToString()) {
                        return;
                    }
                    var logger = _loggerCache.GetOrAdd(component, key => ctx.Resolve<ILogger>(new TypedParameter(typeof(Type), componentType)));
                    propertyInfo.SetValue(instance, logger, null);
                };
            }
        }    

其实它的核心就是注册时通过对象类型查找是否有一个类型为Ilogger的可读写属性，拿出来赋值。

 

　　2. 通过动态代理实现的事件机制：

　　在.Net中提到事件就会想到委托，但是Orchard的事件比较特殊，它将事件定义为一个接口(实现IEventHandler的接口)，对于生产者(事件发布者)它仅需要通过Orchard的容器注入一个相应接口类型即可，而观察者(事件的真实处理器)则仅需要实现相应接口即可(其余框架会自动处理)。

对.Net的委托不了解的可参考张子阳老师的博客：http://www.cnblogs.com/JimmyZhang/archive/2007/09/23/903360.html

Orchard事件的使用如下(使用张子阳老师例子改了一下)：

        public interface IBoilHandler : IEventHandler
        {
            void OnTemperatureChanged(int temperature);
        }
 
        // 热水器
        public class Heater
        {
            private int temperature;
            private IBoilHandler _boilhandler;
 
            public Heater(IBoilHandler boilhandler)
            {
                _boilhandler = boilhandler;
            }
 
            // 烧水
            public void BoilWater()
            {
                for (int i = 0; i <= 100; i++)
                {
                    temperature = i;
 
                    if (temperature > 95)
                    {
                        if (_boilhandler != null)
                        { //如果有对象注册
                            _boilhandler.OnTemperatureChanged(temperature);  //调用所有注册对象的方法
                        }
                    }
                }
            }
        }
 
        // 警报器
        public class Alarm : IBoilHandler
        {
            public void OnTemperatureChanged(int temperature)
            {
                Console.WriteLine("Alarm：嘀嘀嘀，水已经 {0} 度了：", temperature);
            }
        }
 
        // 显示器
        public class Display : IBoilHandler
        {
            public void OnTemperatureChanged(int temperature)
            {
                Console.WriteLine("Display：水快烧开了，当前温度：{0}度。", temperature);
            }
        } 

 

那么这是如何实现的呢？

两个要点：

　　1. 在注册服务时将所有通过继承IEventhandler的子接口(如上面代码的IBoilHandler)通过动态代理，将相应接口的方法执行全部拦截并转到EventBus上，调用Notify方法，其参数为当前接口名称+方法名称和相应的参数。--生产者

　　public class EventsRegistrationSource : IRegistrationSource {
        private readonly DefaultProxyBuilder _proxyBuilder;
 
        public EventsRegistrationSource() {
            _proxyBuilder = new DefaultProxyBuilder();
        }
 
        public bool IsAdapterForIndividualComponents {
            get { return false; }
        }
 
        public IEnumerable<IComponentRegistration> RegistrationsFor(Service service, Func<Service, IEnumerable<IComponentRegistration>> registrationAccessor) {
            var serviceWithType = service as IServiceWithType;
            if (serviceWithType == null)
                yield break;
 
            var serviceType = serviceWithType.ServiceType;
            if (!serviceType.IsInterface || !typeof(IEventHandler).IsAssignableFrom(serviceType) || serviceType == typeof(IEventHandler))
                yield break;
 
            var interfaceProxyType = _proxyBuilder.CreateInterfaceProxyTypeWithoutTarget(
                serviceType,
                new Type[0],
                ProxyGenerationOptions.Default);
 
 
            var rb = RegistrationBuilder
                .ForDelegate((ctx, parameters) => {
                    var interceptors = new IInterceptor[] { new EventsInterceptor(ctx.Resolve<IEventBus>()) };
                    var args = new object[] { interceptors, null };
                    return Activator.CreateInstance(interfaceProxyType, args);
                })
                .As(service);
 
            yield return rb.CreateRegistration();
        }
    }
 
    public class EventsInterceptor : IInterceptor {
        private readonly IEventBus _eventBus;
        private static readonly ConcurrentDictionary<Type,MethodInfo> _enumerableOfTypeTDictionary = new ConcurrentDictionary<Type, MethodInfo>();
 
        public EventsInterceptor(IEventBus eventBus) {
            _eventBus = eventBus;
        }
 
        public void Intercept(IInvocation invocation) {
            var interfaceName = invocation.Method.DeclaringType.Name;
            var methodName = invocation.Method.Name;
 
            var data = invocation.Method.GetParameters()
                .Select((parameter, index) => new { parameter.Name, Value = invocation.Arguments[index] })
                .ToDictionary(kv => kv.Name, kv => kv.Value);
 
            var results = _eventBus.Notify(interfaceName + "." + methodName, data);
 
            invocation.ReturnValue = Adjust(results, invocation.Method.ReturnType);
        }
 
        public static object Adjust(IEnumerable results, Type returnType) {
            if (returnType == typeof(void) ||
                results == null ||
                results.GetType() == returnType) {
                return results;
            }
 
            // acquire method:
            // static IEnumerable<T> IEnumerable.OfType<T>(this IEnumerable source)
            // where T is from returnType's IEnumerable<T>
            var enumerableOfTypeT = _enumerableOfTypeTDictionary.GetOrAdd( returnType, type => typeof(Enumerable).GetGenericMethod("OfType", type.GetGenericArguments(), new[] { typeof(IEnumerable) }, typeof(IEnumerable<>)));
            return enumerableOfTypeT.Invoke(null, new[] { results });
        }
    }

　　上面代码有个重点就是：

 if (!serviceType.IsInterface || !typeof(IEventHandler).IsAssignableFrom(serviceType) || serviceType == typeof(IEventHandler))
                yield break;

　　如果不是接口、如果类型不是IEventHandler的子类型(子接口)且当前类型就是IEventHandler，满足这三个接口就跳出。正过来说就是：

• 　类型一定是接口
• 　一定是继承IEventHandler的接口
• 　一定不是IEventHandler本身

　　2. 把所有实现了IEventHandler的实现全部解析到EventBus的_eventHandlers字段中。 --消费者

换句话说就是，当应用程序初始化的时候EventBus里面的处理器都已经被加载了，但真正触发事件时，仅仅是通过拦截器将相应接口的方法转到了Notify方法上，进而去通知相应的Handlers执行。

下面代码位于ShellContainerFactory.cs文件中

　　　　　　　　　　　　　　if (typeof(IEventHandler).IsAssignableFrom(item.Type)) {
                            var interfaces = item.Type.GetInterfaces();
                            foreach (var interfaceType in interfaces) {
 
                                // register named instance for each interface, for efficient filtering inside event bus
                                // IEventHandler derived classes only
                                if (interfaceType.GetInterface(typeof (IEventHandler).Name) != null) {
                                    registration = registration.Named<IEventHandler>(interfaceType.Name);
                                }
                            }
                        }

 

　　3. ICacheManager的注入：

ICacheManager的特殊之处就在于依赖它的对象在通过构造注入ICacheManager会将当前对象作为参数来实例化ICacheManager。

        protected override void AttachToComponentRegistration(Autofac.Core.IComponentRegistry componentRegistry, Autofac.Core.IComponentRegistration registration) {
            var needsCacheManager = registration.Activator.LimitType
                .GetConstructors()
                .Any(x => x.GetParameters()
                    .Any(xx => xx.ParameterType == typeof(ICacheManager)));
 
            if (needsCacheManager) {
                registration.Preparing += (sender, e) => {
                    var parameter = new TypedParameter(
                        typeof(ICacheManager),
                        e.Context.Resolve<ICacheManager>(new TypedParameter(typeof(Type), registration.Activator.LimitType)));
                    e.Parameters = e.Parameters.Concat(new[] { parameter });
                };
            }
        }

 

小结：

本章主要是分析了Orchard中IoC容器的创建以及基础设施的注册，其中对Log、Event和CacheManager进行了特殊处理，并且处理方式均是使用Autofac提供的一系列特性，动态的对注册的组件进行额外操作，另外在Orchard中它还针对Shell级别创建了一个子容器，所以后续将对Orchard的依赖注入进一步分析。

 

参考：

http://www.cnblogs.com/alby/archive/2012/10/18/orchard-EventsModule.html

http://autofac.readthedocs.io/en/latest/

http://www.cnblogs.com/JimmyZhang/archive/2007/09/23/903360.html