C# IUnityContainer.AddExtension方法代码示例

        public static ITypeFactory Boot(string loggerName,Assembly asm)
        {
            XmlConfigurator.Configure();
            container = new UnityContainer();

            RegisterKnownTypes(asm);
            RegisterKnownTypes(typeof(ITypeFactory).Assembly);

            container.RegisterInstance<ITypeFactory>(new TypeFactory(container));
            container.RegisterInstance<ILog>(LogManager.GetLogger(loggerName));

            container.RegisterInstance<ICommandRouter>(new CommandRouterImpl());
            factory = container.Resolve<ITypeFactory>();

            factory.Get<ILog>().Info(".=.=.=. " + Assembly.GetExecutingAssembly().GetName().Name + " =.=.=.=");
            factory.Get<ILog>().Info("Version:" + Assembly.GetExecutingAssembly().GetName().Version.ToString());

            string dataPath = ApplicationEnvironment.Instance.DataPath;
            if (!Directory.Exists(dataPath))
            {
                factory.Get<ILog>().Error("L'applicazione non riesce a creare il percorso dati:" + dataPath);
            }
            factory.Get<ILog>().Debug("Data path applicazione:"+dataPath);

            container.AddExtension(new WireImportExports());
            return factory;
        }

        protected override void ConfigureContainer(IUnityContainer container)
        {
            Microsoft.Practices.Unity.Utility.Guard.ArgumentNotNull(container, "container");

            var extensionType = this.GetExtensionType();
            var extension = (UnityContainerExtension)container.Resolve(extensionType);
            container.AddExtension(extension);
        }

        public void SetUp()
        {
            container = new UnityContainer();

            settings = new ExceptionHandlingSettings();
            configurationSource = new DictionaryConfigurationSource();
            configurationSource.Add(ExceptionHandlingSettings.SectionName, settings);

            container.AddExtension(new EnterpriseLibraryCoreExtension(configurationSource));
        }

        /// <summary>
        /// Creates the instance of the Unity container.
        /// </summary>
        protected override void PreCompose()
        {
            unityContainer = new UnityContainer();

            var locator = new UnityServiceLocator(unityContainer);
            exportProvider = new CSLExportProvider(locator);

            unityContainer.AddExtension(new CSLExportProviderExtension(exportProvider));

            RegisterTypes();
        }

        public void Init(HttpApplication context)
        {
            if (_container == null)
            {
                var appAsUnityAccessor = (context as IUnityContainerAccessor);
                if (appAsUnityAccessor == null)
                    throw new Exception("The http application must implement \"Thingie.Tracking.Unity.ASPNET.IUnityContainerAccessor\" for the TrackingModule to work! Please implement the interface in global.asax.");

                _container = appAsUnityAccessor.Container;
                RegisterTrackers(_container);
                _container.AddExtension(new TrackingExtension());
            }

            context.PreRequestHandlerExecute += new EventHandler(context_PreRequestHandlerExecute);
            context.PostRequestHandlerExecute += new EventHandler(context_PostRequestHandlerExecute);
        }

        protected override void ConfigureContainer(IUnityContainer container)
        {
            var interception = new ExtendedInterception();
            if (!string.IsNullOrEmpty(Interceptor))
            {
                var type = Type.GetType(Interceptor);
                if (null == type)
                {
                    throw new ConfigurationErrorsException(string.Format("The {0} is not a valid Interceptor.",
                        Interceptor));
                }

                if (!typeof (IInterceptor).IsAssignableFrom(type))
                {
                    throw new ConfigurationErrorsException(string.Format("The {0} is not a valid Interceptor.",
                        Interceptor));
                }
                interception.Interceptor = (IInterceptor) Activator.CreateInstance(type);
            }

            container.AddExtension(interception);
        }

		public void SetUp()
		{
			container = new UnityContainer();
			container.AddExtension(new EnterpriseLibraryCoreExtension());
			CryptographerFixture.CreateKeyFile(keyedHashKeyFile);
		}

 public virtual void Setup()
 {
     Container = new UnityContainer();
     MockUnit.Setup();
     Container.AddExtension(MockUnit.Extension);
 }

 public void SetUp()
 {
     container = new UnityContainer();
     container.AddExtension(new EnterpriseLibraryCoreExtension());
 }

 private void RegisterTypes(IUnityContainer container)
 {
     //Register Common unity container
     var commonContainer = new CommonUnityExtension();
     container.AddExtension(commonContainer);
 }

 /// <summary>
 /// Add the extension specified in this element to the container.
 /// </summary>
 /// <param name="container">Container to configure.</param>
 protected override void ConfigureContainer(IUnityContainer container)
 {
     var extensionType = GetExtensionType();
     var extension = (UnityContainerExtension)container.Resolve(extensionType);
     container.AddExtension(extension);
 }