C# IUnityContainer.RegisterInstance方法代码示例

        /// <summary>Registers the type mappings with the Unity container.</summary>
        /// <param name="container">The unity container to configure.</param>
        /// <remarks>There is no need to register concrete types such as controllers or API controllers (unless you want to 
        /// change the defaults), as Unity allows resolving a concrete type even if it was not previously registered.</remarks>
        public static void RegisterTypes(IUnityContainer container) {
            //Standard configuration
            StandardUnityConfig.RegisterStandardFacetFactories(container);
            StandardUnityConfig.RegisterCoreContainerControlledTypes(container);
            StandardUnityConfig.RegisterCorePerTransactionTypes<PerRequestLifetimeManager>(container);

            // config
            container.RegisterInstance<IReflectorConfiguration>(NakedObjectsRunSettings.ReflectorConfig(), (new ContainerControlledLifetimeManager()));
            container.RegisterInstance<IEntityObjectStoreConfiguration>(NakedObjectsRunSettings.EntityObjectStoreConfig(), new ContainerControlledLifetimeManager());


            // surface
            container.RegisterType<IOidTranslator, OidTranslatorSemiColonSeparatedList>(new PerRequestLifetimeManager());

            container.RegisterType<IOidStrategy, EntityOidStrategy>(new PerRequestLifetimeManager());
            container.RegisterType<IIdHelper, IdHelper>(new PerRequestLifetimeManager());

            container.RegisterType<IFrameworkFacade, FrameworkFacade>(new PerRequestLifetimeManager());

            //Externals
            container.RegisterType<IPrincipal>(new InjectionFactory(c => HttpContext.Current.User));

            // Facet decorators 
            if (NakedObjectsRunSettings.AuditConfig() != null) {
                container.RegisterType(typeof(IFacetDecorator), typeof(AuditManager), "AuditManager", new ContainerControlledLifetimeManager());
                container.RegisterInstance(typeof(IAuditConfiguration), NakedObjectsRunSettings.AuditConfig(), new ContainerControlledLifetimeManager());
            }

            if (NakedObjectsRunSettings.AuthorizationConfig() != null) {
                container.RegisterType(typeof(IFacetDecorator), typeof(AuthorizationManager), "AuthorizationManager", new ContainerControlledLifetimeManager());
                container.RegisterInstance(typeof(IAuthorizationConfiguration), NakedObjectsRunSettings.AuthorizationConfig(), new ContainerControlledLifetimeManager());
            }
        }

        protected override void OnStartup(StartupEventArgs e)
        {
            XmlConfigurator.Configure();

            _logger.Info("[START]");
            _logger.Info("setup dependency injection container");
            Container = new UnityContainer();

            _logger.Info("setup database");
            string directory = Environment.GetFolderPath(
                Environment.SpecialFolder.LocalApplicationData);
            _logger.Info("database directory: " + directory);
            _dbContext = new NDatabaseConnector(directory);

            //database registration
            Container.RegisterInstance(typeof (IDataAccessLayer), _dbContext);

            //service registrations
            Container.RegisterType<ICryptographyService, CryptographyService>();
            Container.RegisterType<IDropboxService, DropboxService>();

            //registraions utils
            //only one instance from messenger can exists! (recipient problems..)
            _logger.Info("register messenger instance");
            var messenger = new Messenger();
            Container.RegisterInstance(typeof (IMessenger), messenger);

            _logger.Info("show login view");
            var loginView = Container.Resolve<LoginView>();
            loginView.Show();
        }

        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;
        }

        /// <summary>Registers the type mappings with the Unity container.</summary>
        /// <param name="container">The unity container to configure.</param>
        /// <remarks>There is no need to register concrete types such as controllers or API controllers (unless you want to 
        /// change the defaults), as Unity allows resolving a concrete type even if it was not previously registered.</remarks>
        public static void RegisterTypes(IUnityContainer container)
        {
            // NOTE: To load from web.config uncomment the line below. Make sure to add a Microsoft.Practices.Unity.Configuration to the using statements.
            // container.LoadConfiguration();
            container.RegisterType<IHtmlString, AnnotationWidget>("AnnotationWidget");

            string repositoryFolder = AppDomain.CurrentDomain.GetData("DataDirectory") + "/";
            var annotator = new AnnotationImageHandler(
               new AnnotationConfig { StoragePath = repositoryFolder }
                //new Data.Json.Repositories.UserRepository(repositoryFolder),
                //new Data.Json.Repositories.DocumentRepository(repositoryFolder),
                //new Data.Json.Repositories.AnnotationRepository(repositoryFolder),
                //new Data.Json.Repositories.AnnotationReplyRepository(repositoryFolder),
                //new Data.Json.Repositories.AnnotationCollaboratorRepository(repositoryFolder)
                );

            container.RegisterInstance(typeof(IUserDataHandler), annotator.GetUserDataHandler());

            #region Instances
            //container.RegisterInstance(typeof (IDocumentDataHandler), new DocumentRepository(repositoryFolder));
            //container.RegisterInstance(typeof(IAnnotationCollaboratorDataHandler), new AnnotationCollaboratorRepository(repositoryFolder));
            //container.RegisterInstance(typeof(IAnnotationReplyDataHandler), new AnnotationReplyRepository(repositoryFolder));
            //container.RegisterInstance(typeof(IAnnotationDataHandler), new AnnotationRepository(repositoryFolder));
            //container.RegisterInstance(typeof(IInputDataHandler), new InputDataHandler(repositoryFolder));
            //container.RegisterInstance(typeof(IFileDataStore), new FileStore(repositoryFolder));
            #endregion Instances
            
            container.RegisterInstance(typeof(AnnotationImageHandler), annotator);
            container.RegisterType<IAnnotationService, AnnotationService>();
            container.RegisterType<IAuthenticationService, AuthenticationService>();
            container.RegisterType<IAnnotationBroadcaster, AnnotationBroadcaster>();
            container.RegisterType<IAnnotationHub, AnnotationHub>();
        }

 protected override void RegistrateTypes(IUnityContainer container)
 {
     container.RegisterInstance(container);
     container.RegisterInstance(new ConfigurationManager(Product.Display.AppName, SpecialFolder.ApplicationData));
     container.RegisterType<AppSettings>(
        new InjectionFactory(c => c.Resolve<ConfigurationManager>().GetSection<AppSettings>(AppSettings.SectionKey)));
 }

 public UpdaterModule(IUnityContainer container, IRegionManager manager)
 {
     _container = container;
     _regionManager = manager;
     _container.RegisterInstance(_container.Resolve<UpdaterViewModel>());
     _container.RegisterInstance<IEsterViewModel>("updates", _container.Resolve<UpdaterViewModel>());
 }

 public Shell(IUnityContainer container, IEventAggregator evtAggregator)
 {
     InitializeComponent();
     container.RegisterInstance<Panel>("MainRegion", m_MainRegionPanel);
     container.RegisterInstance<Panel>("SecondRegion", m_SecondRegionPanel);
     evtAggregator.GetEvent<ProductSavedEvent>().Subscribe(OnProductSaved,ThreadOption.SubscriberAffinityThread);
 }

        /// <summary>Registers the type mappings with the Unity container.</summary>
        /// <param name="container">The unity container to configure.</param>
        /// <remarks>There is no need to register concrete types such as controllers or API controllers (unless you want to 
        /// change the defaults), as Unity allows resolving a concrete type even if it was not previously registered.</remarks>
        public static void RegisterTypes(IUnityContainer container) {
            // NOTE: To load from web.config uncomment the line below. Make sure to add a Microsoft.Practices.Unity.Configuration to the using statements.
            // container.LoadConfiguration();
            //Standard configuration

            try {

                StandardUnityConfig.RegisterStandardFacetFactories(container);
                StandardUnityConfig.RegisterCoreContainerControlledTypes(container);
                StandardUnityConfig.RegisterCorePerTransactionTypes<PerResolveLifetimeManager>(container);

                // config 
                container.RegisterInstance<IReflectorConfiguration>(NakedObjectsRunSettings.ReflectorConfig(), (new ContainerControlledLifetimeManager()));
                container.RegisterInstance<IEntityObjectStoreConfiguration>(NakedObjectsRunSettings.EntityObjectStoreConfig(), new ContainerControlledLifetimeManager());

                // frameworkFacade
                container.RegisterType<IOidTranslator, OidTranslatorSlashSeparatedTypeAndIds>(new PerResolveLifetimeManager());

                container.RegisterType<IOidStrategy, EntityOidStrategy>(new PerResolveLifetimeManager());
                container.RegisterType<IStringHasher, SimpleStringHasher>(new PerResolveLifetimeManager());
                container.RegisterType<IFrameworkFacade, FrameworkFacade>(new PerResolveLifetimeManager());

                //Externals
                container.RegisterType<IPrincipal>(new InjectionFactory(c => HttpContext.Current.User));
            }
            catch (Exception e) {
                Logger.Error($"Error on Unity RegisterTypes : {e.Message}");
                throw;
            }

        }

        protected override void Arrange()
        {
            base.Arrange();

            UIServiceMock = new Mock<IUIServiceWpf>(MockBehavior.Strict);

            Container = new UnityContainer();

            Container.RegisterType<AssemblyLocator, BinPathProbingAssemblyLocator>(new ContainerControlledLifetimeManager());
            Container.RegisterType<ConfigurationSectionLocator, AssemblyAttributeSectionLocator>(new ContainerControlledLifetimeManager());
            Container.RegisterType<AnnotationService>(new ContainerControlledLifetimeManager());
            Container.RegisterType<ElementLookup>(new ContainerControlledLifetimeManager());
            Container.RegisterType<DiscoverDerivedConfigurationTypesService>(new ContainerControlledLifetimeManager());
            Container.RegisterType<ConfigurationSourceModel>(new ContainerControlledLifetimeManager());
            Container.RegisterType<ConfigurationSourceDependency>(new ContainerControlledLifetimeManager());
            Container.RegisterType<AnnotationService>(new ContainerControlledLifetimeManager());
            Container.RegisterType(typeof(IResolver<>), typeof(GenericResolver<>));
            Container.RegisterInstance<IServiceProvider>(new ContainerProvider(Container));
            Container.RegisterInstance<IUIServiceWpf>(UIServiceMock.Object);
            Container.RegisterType<SaveOperation>(new ContainerControlledLifetimeManager());

            Container.RegisterType<IApplicationModel, ApplicationViewModel>(new ContainerControlledLifetimeManager());

            AnnotationService annotationService = Container.Resolve<AnnotationService>();
            annotationService.DiscoverSubstituteTypesFromAssemblies();
        }

        public static IUnityContainer GetInstance()
        {
            if (container == null)
            {
                container = new UnityContainer();

                /// RegisterType 创建的实例默认不是单例模式的实例 LifetimeManager 这个可以用来把它设置成单例模式
                //// 泛型参数方式
                //// 注册接口映射  满足条件：IUnityContainer RegisterType<TFrom, TTo>() where TTo : TFrom
                //container.RegisterType<ILogger, DatabaseLogger>();

                //// 注册接口映射 用下面这种方式，带参数的，就要Microsoft.Practices.ObjectBuilder2.dll
                //// 因为 方法：IUnityContainer RegisterType(Type t, params InjectionMember[] injectionMembers)中的 参数 InjectionMember
                //// 有用到 Microsoft.Practices.ObjectBuilder2.dll 中的接口，所以添加对Microsoft.Practices.ObjectBuilder2.dll的引用
                //container.RegisterType<ILogger, FlatFileLogger>("FlatFileLogger");

                // // 参数方式
                //container.RegisterType(typeof(ILogger), typeof(DatabaseLogger));
                //container.RegisterType(typeof(ILogger), typeof(FlatFileLogger), "FlatFileLogger");

                /// RegisterInstance 创建的实例默认是单例模式的，但也要防止这个创建实例的单例创建
                container.RegisterInstance<ILogger>(new DatabaseLogger());
                container.RegisterInstance<ILogger>("FlatFileLogger",new FlatFileLogger());

            }

            return container;
        }

        public static void SetupContainer()
        {
            // Create User
            var user = new CurrentUser() { Username = "GDP1", LabCode = "EUHAWE3" };

            // Create Logger
            var logger = new LoggerConfiguration()
              .Enrich.FromLogContext()
                .MinimumLevel.Warning()                 // Set MinimumLevel of Warning
                .WriteTo.Seq("http://localhost:5341")
              .CreateLogger();

            unityContainer = new UnityContainer();

            // Register User
            unityContainer.RegisterInstance<ICurrentUser>(user);

            // Add Interception Extension
            unityContainer.AddNewExtension<Microsoft.Practices.Unity.InterceptionExtension.Interception>();

            //Register Logger Instance
            unityContainer.RegisterInstance<ILogger>(logger);

            unityContainer.RegisterType<ISamRepository, SamRepository>()
                .Configure<Microsoft.Practices.Unity.InterceptionExtension.Interception>()
                .SetInterceptorFor<ISamRepository>(
                    new InterfaceInterceptor());
        }

        /// <summary>Registers the type mappings with the Unity container.</summary>
        /// <param name="container">The unity container to configure.</param>
        /// <remarks>There is no need to register concrete types such as controllers or API controllers (unless you want to 
        /// change the defaults), as Unity allows resolving a concrete type even if it was not previously registered.</remarks>
        public static void RegisterTypes(IUnityContainer container) {
            // NOTE: To load from web.config uncomment the line below. Make sure to add a Microsoft.Practices.Unity.Configuration to the using statements.
            // container.LoadConfiguration();
            //Standard configuration

            StandardUnityConfig.RegisterStandardFacetFactories(container);
            StandardUnityConfig.RegisterCoreContainerControlledTypes(container);
            StandardUnityConfig.RegisterCorePerTransactionTypes<HierarchicalLifetimeManager>(container);

            // add custom notnavigable factory

            UnityConfigHelpers.RegisterFacetFactory(typeof(AWNotNavigableFacetFactory), container, 1000);
            UnityConfigHelpers.RegisterFacetFactory(typeof(AWNotCountedAnnotationFacetFactory), container, 1001);

            // config 
            container.RegisterInstance<IReflectorConfiguration>(NakedObjectsRunSettings.ReflectorConfig(), (new ContainerControlledLifetimeManager()));
            container.RegisterInstance<IEntityObjectStoreConfiguration>(NakedObjectsRunSettings.EntityObjectStoreConfig(), new ContainerControlledLifetimeManager());

            // surface
            container.RegisterType<IOidTranslator, OidTranslatorSlashSeparatedTypeAndIds>(new HierarchicalLifetimeManager());

            container.RegisterType<IOidStrategy, EntityOidStrategy>(new HierarchicalLifetimeManager());
            container.RegisterType<IStringHasher, SimpleStringHasher>(new HierarchicalLifetimeManager());
            container.RegisterType<IFrameworkFacade, FrameworkFacade>(new HierarchicalLifetimeManager());

            //Externals
            container.RegisterType<IPrincipal>(new InjectionFactory(c => HttpContext.Current.User));
        }

        public static void RegisterTypes(IUnityContainer container)
        {
            var hierarchy = (Hierarchy)LogManager.GetRepository();
            hierarchy.Root.RemoveAllAppenders();

            hierarchy.Root.Level = Level.Debug;
            hierarchy.RaiseConfigurationChanged(EventArgs.Empty);

            FileAppender fileAppender = new RollingFileAppender();
            fileAppender.AppendToFile = true;
            fileAppender.LockingModel = new FileAppender.MinimalLock();
            fileAppender.File = HttpContext.Current.Server.MapPath("~/TestHarness1.log.txt");
            var patternLayout = new PatternLayout { ConversionPattern = "%d [%2%t] %-5p [%-10c]   %m%n%n" };
            patternLayout.ActivateOptions();

            fileAppender.Layout = patternLayout;
            fileAppender.ActivateOptions();

            BasicConfigurator.Configure(fileAppender);

            var logger = LogManager.GetLogger(typeof(IServiceBus));

            container.RegisterInstance<ILog>(logger, new ContainerControlledLifetimeManager());

            var ftpClient = new FtpQueueClient();
            ftpClient.ConnectAsync(new Uri("ftp://ftp.jdibble.co.uk/site1/Personal/service-bus-ftp/queue"), new NetworkCredential("jdibble-001", "jli798ik")).Wait();

            container.RegisterInstance<IFtpQueueClient>(ftpClient, new ContainerControlledLifetimeManager());

            container.RegisterType<IQueueManager, FtpQueueManager>(new ContainerControlledLifetimeManager());

            container.RegisterType<SharedMessageHandler>();

            var messageDictionary = new MessageTypeDictionary
                                    {
                                        { ServiceBus.Messaging.MessageExtensions.MessageTypeSignature<SharedMessage>(), typeof(SharedMessage) },
                                        { ServiceBus.Messaging.MessageExtensions.MessageTypeSignature<NonSharedMessage>(), typeof(NonSharedMessage) },
                                        { ServiceBus.Messaging.MessageExtensions.MessageTypeSignature<SharedEvent>(), typeof(SharedEvent) }
                                    };

            container.RegisterInstance<IMessageSerialiser>(new JsonMessageSerialiser(messageDictionary), new ContainerControlledLifetimeManager());

            var serviceBus =
                ServiceBusBuilder.Configure()
                    .WithLogger(container.Resolve<ILog>())
                    .WithHostAddress(new Uri("http://servicebus-ftp.jdibble.co.uk"))
                    .WithHttpTransport(new JsonMessageSerialiser(messageDictionary))
                    .AsMvcServiceBus(RouteTable.Routes, container.Resolve<IQueueManager>())
                    .Build()
                        .WithMessageHandler(container.Resolve<SharedMessageHandler>())
                        .Subscribe(container.Resolve<SharedEventHandler>())
                        .WithPeerAsync(new Peer(new Uri("http://servicebus-ftp2.jdibble.co.uk"))).Result;

            serviceBus.WithPeerAsync(new Peer(new Uri("http://servicebus.jdibble.co.uk")));
            serviceBus.WithPeerAsync(new Peer(new Uri("http://servicebus2.jdibble.co.uk")));

            container.RegisterInstance(serviceBus, new ContainerControlledLifetimeManager());

            container.RegisterType<ServiceBusHub>(new ContainerControlledLifetimeManager());
        }

 private Container() 
 {
     unityContainer = new UnityContainer();
     unityContainer.RegisterInstance<UsersService>(new UsersService());
     unityContainer.RegisterInstance<LocationsService>(new LocationsService());
     unityContainer.RegisterInstance<ReferenceData.DAL.Services.SubdivisionService>(new ReferenceData.DAL.Services.SubdivisionService());
     unityContainer.RegisterInstance<CountriesService>(new CountriesService());
 }

 private UnityServiceRegistry(UnityServiceRegistry parent)
 {
     _parent = parent;
     _container = _parent != null ? _parent._container.CreateChildContainer() : new UnityContainer();
     _container.RegisterInstance<IServiceRegistry>(this);
     _locator = new UnityServiceLocator(_container, _parent != null ? _parent._locator : null);
     _container.RegisterInstance<IServiceLocator>(Locator);
 }