IoC之Unity實現

public static class Bootstrapper    {        PRivate static ILog logger = LogManager.GetLogger(typeof(Bootstrapper));        static Bootstrapper()        {            try            {                logger.Info("start load container");                Container.InitializeWith(new DependencyResolverFactory());            }            catch (Exception ex)            {                logger.Fatal(ex);            }        }        public static void Run()        {            logger.Info("start run bootstrapper task...");            Container.ResolveAll<IBackgroundTask>().ForEach(action =>            {                action.Start();            });        }    }

public interface IDependencyResolverFactory    {        IDependencyResolver CreateInstance();    }public interface IDependencyResolver : IDisposable    {        void Register<T>(T instance);        void Inject<T>(T existing);        T Resolve<T>(Type type);        T Resolve<T>(Type type, string name);        T Resolve<T>();        T Resolve<T>(string name);        IEnumerable<T> ResolveAll<T>();    }

public class DependencyResolverFactory : IDependencyResolverFactory    {        private static ILog logger = LogManager.GetLogger(typeof(DependencyResolverFactory));        private static Dictionary<string, IDependencyResolver> dictDependency = new Dictionary<string, IDependencyResolver>();        private readonly Type _resolverType;                public DependencyResolverFactory(string resolverTypeName)        {            _resolverType = Type.GetType(resolverTypeName, true, true);        }        public DependencyResolverFactory()            : this(ConfigurationManager.AppSettings["dependencyResolverTypeName"])        {        }        public IDependencyResolver CreateInstance()        {            try            {                if (dictDependency.ContainsKey(_resolverType.FullName))                {                    return dictDependency[_resolverType.FullName];                }                var instance = Activator.CreateInstance(_resolverType, new object[] {"" }) as IDependencyResolver;                dictDependency.Add(_resolverType.FullName, instance);                return instance;            }            catch (Exception exception)            {                logger.Error(exception);            }            return null;        }    }

public class UnityDependencyResolver : DisposableResource,IDependencyResolver    {        private readonly IUnityContainer container;        private static object syncObject = new object();        private static Dictionary<string, IUnityContainer> containers = new Dictionary<string, IUnityContainer>();        public UnityDependencyResolver(IUnityContainer container)        {            this.container = container;        }        public UnityDependencyResolver(string containerName = ""):this(new UnityContainer().AddNewExtension<Interception>())        {            if (containers.ContainsKey(containerName))            {                this.container = containers[containerName];            }            else            {                lock (syncObject)                {                    UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");                    if (section == null)                    {                        throw new ConfigurationErrorsException("The Unity configuration section does not exist");                    }                    IUnityContainer con = new UnityContainer();                    if (string.IsNullOrEmpty(containerName))                    {                        section.Configure(con);                    }                    else                    {                        section.Configure(con, containerName);                    }                    containers.Add(containerName, con);                    this.container = containers[containerName];                }            }        }        public void Register<T>(T instance)        {            container.RegisterInstance(instance);        }        public void Inject<T>(T instance)        {            container.BuildUp(instance);        }        public T Resolve<T>(Type type)        {            return (T)container.Resolve(type);        }        public T Resolve<T>(Type type, string name)        {            return (T)container.Resolve(type, name);        }        public T Resolve<T>()        {            return container.Resolve<T>();        }        public T Resolve<T>(string name)        {            return container.Resolve<T>(name);        }        public IEnumerable<T> ResolveAll<T>()        {            return container.ResolveAll<T>();        }        protected override void Dispose(bool disposing)        {            if (disposing)            {                container.Dispose();            }            base.Dispose(disposing);        }    }

<?xml version="1.0" encoding="utf-8" ?><configuration>  <configSections>    <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Microsoft.Practices.Unity.Configuration" />  </configSections>  <unity xmlns="http://schemas.microsoft.com/practices/2010/unity">    <sectionExtension type="Microsoft.Practices.Unity.InterceptionExtension.Configuration.InterceptionConfigurationExtension, Microsoft.Practices.Unity.Interception.Configuration" />    <!-- BackgroundTask -->    <alias alias="IBackgroundTask" type="UnitySample.Core.Infrastructure.IBackgroundTask,UnitySample.Core"/>    <alias alias="UserSettingBackgroundTask" type="UnitySample.Core.Infrastructure.UserSettingBackgroundTask,UnitySample.Core"/>    <!-- Dao-->    <alias alias="CacheDataDao" type="UnitySample.Core.Dao.CacheDataDao,UnitySample.Core"/>    <alias alias="FunctionCatalogDao" type="UnitySample.Core.Dao.FunctionCatalogDao,UnitySample.Core"/>    <alias alias="FunctionDao" type="UnitySample.Core.Dao.FunctionDao,UnitySample.Core"/>    <alias alias="ConfigSettingDao" type="UnitySample.Core.Dao.ConfigSettingDao,UnitySample.Core"/>    <!-- Cache -->    <alias alias="ICache" type="UnitySample.Core.Infrastructure.Caching.ICache,UnitySample.Core"/>    <alias alias="CacheImpl" type="UnitySample.Core.Infrastructure.Caching.CacheImpl,UnitySample.Core"/>    <!-- db helper-->    <alias alias="SQLiteHelper" type="UnitySample.Core.Dataaccess.SQLiteHelper,UnitySample.Core" />    <!-- config -->    <alias alias="IConfigurationSettings" type="UnitySample.Core.Configuration.IConfigurationSettings,UnitySample.Core"/>    <alias alias="ConfigurationSettings" type="UnitySample.Core.Configuration.ConfigurationSettings,UnitySample.Core"/>    <alias alias="IEventAggregator" type="UnitySample.Core.Infrastructure.IEventAggregator,UnitySample.Core"/>    <alias alias="EventAggregator" type="UnitySample.Core.Infrastructure.EventAggregator,UnitySample.Core"/>    <container>      <extension type="Interception" />      <!-- BackgroundTask-->      <register type="IBackgroundTask" mapTo="UserSettingBackgroundTask" name="UserSettingTask">        <lifetime type="singleton"/>        <constructor>          <param name="eventAggregator" dependencyType="IEventAggregator" />          <param name="configDao" dependencyType="ConfigSettingDao" />        </constructor>      </register>      <!-- Cache -->      <register type="ICache" mapTo="CacheImpl" name="MemoryCache">        <lifetime type="singleton"/>        <constructor>          <param name="cacheManagerName" value="MemoryCache" />        </constructor>      </register>      <register type="ICache" mapTo="CacheImpl" name="FileCache">        <lifetime type="singleton"/>        <constructor>          <param name="cacheManagerName" value="F