C# IContainer.Register方法代码示例

        private static void ApplySetup(CqrsConfigurationSetup config)
        {
            Container = config.Container;
            Container.RegisterSingle(Container);

            if (config.IsUsingDefaultDispatchers)
            {
                Container.Register<IQueryDispatcher, QueryDispatcher>();
                Container.Register<ICommandDispatcher, CommandDispatcher>();
            }

            if (!config.Assemblies.Any())
                return;

            var queryHandlerType = typeof(IQueryHandler<,>);
            var commandHandlerType = typeof(ICommandHandler<>);
            var handlers = from a in config.Assemblies
                           from t in a.GetExportedTypes()
                           from i in t.GetInterfaces().Where(i => i.IsGenericType)
                           let generic = i.GetGenericTypeDefinition()
                           where generic == queryHandlerType || generic == commandHandlerType
                           select new { Implementation = t, Contract = i };

            foreach (var handler in handlers)
            {
                Container.Register(handler.Contract, handler.Implementation);
            }
        }

 /// <summary>
 /// Allows a transport to register its dependencies in the IoC container.
 /// </summary>
 /// <param name="container">The container.</param>
 /// <param name="registrationType">Type of the registration.</param>
 /// <param name="connection">The connection.</param>
 /// <param name="queue">The queue.</param>
 public override void RegisterImplementations(IContainer container, RegistrationTypes registrationType, string connection, string queue)
 {
     container.Register<IConnectionInformation>(() => new BaseConnectionInformation(queue, connection),
         LifeStyles.Singleton);
     container.Register<IInternalSerializer, JsonSerializerInternal>(LifeStyles.Singleton);
     container.Register<IWorkerNotificationFactory, WorkerNotificationFactoryNoOp>(LifeStyles.Singleton);
 }

 private static void RegisterHandlers(IContainer container)
 {
     container.Register<IHandler<ShowSettingsMessage>, ShowSettingsHandler>();
     container.Register<IHandler<UpdatedCredentialsMessage>, UpdatedCredentialsHandler>();
     container.Register<IHandler<ShowSearchPaneMessage>, SearchPaneHandler>();
     container.Register<IHandler<SearchIssuesMessage>, SearchIssuesHandler>();
 }

 public void Configure(IContainer container)
 {
     Helper.GuardNotNull(container);
     container.RegisterAsSingleton<ICallManager, ICallManagerInternal, DefaultCallManager>();
     container.Register<ICallBuilder, DefaultCallBuilder>();
     container.Register<Call, Call>();
 }

 public void Configure(IContainer container)
 {
     Helper.GuardNotNull(container);
     container.RegisterAsSingleton<IAccountManager, IAccountManagerInternal, DefaultAccountManager>();
     container.Register<IAccountBuilder, DefaultAccountBuilder>();
     container.Register<Account, Account>();
 }

        private void RegisterService(IContainer container)
        {
            if (Metrics != null)
            {
                container.Register<IMetrics>(() => Metrics, LifeStyles.Singleton);
            }

            if (Des && Gzip)
            {
                container.RegisterCollection<IMessageInterceptor>(new[]
                {
                    typeof (GZipMessageInterceptor), //gzip compression
                    typeof (TripleDesMessageInterceptor) //encryption
                });
                container.Register(() => DesConfiguration, LifeStyles.Singleton);
            }
            else if (Gzip)
            {
                container.RegisterCollection<IMessageInterceptor>(new[]
                {
                    typeof (GZipMessageInterceptor) //gzip compression
                });
            }
            else if (Des)
            {
                container.RegisterCollection<IMessageInterceptor>(new[]
                {
                    typeof (TripleDesMessageInterceptor) //encryption
                });
                container.Register(() => DesConfiguration,
                    LifeStyles.Singleton);
            }
        }

 public void Configure(IContainer container)
 {
     Helper.GuardNotNull(container);
     container.RegisterAsSingleton<IVoIPTransportFactory, DefaultVoIPTransportFactory>();
     container.Register<IVoIPTransport, UdpTransport>(TransportType.Udp.ToString());
     container.Register<IVoIPTransport, TcpTransport>(TransportType.Tcp.ToString());
     container.Register<IVoIPTransport, TlsTransport>(TransportType.Tls.ToString());
 }

 public void Configure(IContainer container)
 {
     Helper.GuardNotNull(container);
     container.RegisterAsSingleton<IConferenceBridge, DefaultConferenceBridge>();
     container.RegisterAsSingleton<IMediaManager, IMediaManagerInternal, DefaultMediaManager>();
     container.Register<CodecInfo, CodecInfo>();
     container.Register<IWavPlayer, WavPlayer>();
 }

 public void Build(IContainer container)
 {
     container.Register<DatabaseFactory, IDatabaseFactory>();
     container.Register<DatabaseContext>();
     container.Register(() =>
     {
         var connectionString = container.Resolve<IChauffeurSettings>().ConnectionString;
         return new UmbracoDatabase(connectionString.ConnectionString, connectionString.ProviderName);
     });
 }

        public static void RegisterDatabase(IContainer container)
        {
            var mainDb = new MainDatabase(container.Resolve<IDbFactory>().Create());

            container.Register<IMainDatabase>(mainDb);

            var logDb = new LogDatabase(container.Resolve<IDbFactory>().Create(MigrationType.Log));

            container.Register<ILogDatabase>(logDb);
        }

        public static void RegisterDatabase(IContainer container)
        {
            var mainDb = container.Resolve<IDbFactory>().Create();

            container.Register(mainDb);

            var logDb = container.Resolve<IDbFactory>().Create(MigrationType.Log);

            container.Register<ILogRepository>(c => new LogRepository(logDb, c.Resolve<IEventAggregator>()));
        }

        public void Configure(IContainer container)
        {
            Helper.GuardNotNull(container);

            container.RegisterAsSingleton<IObjectFactory, DefaultObjectFactory>();
            container.RegisterAsSingleton<IRegistry, IConfigurationContext, DefaultRegistry>();
            container.RegisterAsSingleton<IImManager, IImManagerInternal, DefaultImManager>();
            container.Register<IMessageBuilder, DefaultMessageBuilder>();
            container.Register<IBuddyBuilder, DefaultBuddyBuilder>();
            container.Register<Buddy, Buddy>();
        }

        public static void RegisterDatabase(IContainer container)
        {
            container.Resolve<IDbFactory>().Create();

            container.Register(c => c.Resolve<IDbFactory>().Create());

            container.Resolve<IDbFactory>().Create(MigrationType.Log);

            container.Register<ILogRepository>(c =>
            {
                var db = c.Resolve<IDbFactory>().Create(MigrationType.Log);
                return new LogRepository(db, c.Resolve<IEventAggregator>());
            });
        }

 private static void RegisterHandlers(IContainer container)
 {
     // todo: Add Assembly Scanning here to auto-register
     container.Register<IHandler<ShowSearchPaneMessage>, ShowSearchPaneHandler>();
     container.Register<IHandler<ShareImageResultsMessage>, ShareImageResultsHandler>();
     container.Register<IHandler<ShareUriMessage>, ShareUriHandler>();
     
     container.Register<IHandler<ShowShareUiMessage>, ShowShareUiHandler>();
     container.Register<IHandler<UpdateTileMessage>, UpdateTileHandler>();
     container.Register<IHandler<UpdateTileImageCollectionMessage>, UpdateTileImageCollectionHandler>();
     container.Register<IHandler<ShowSettingsMessage>, ShowSettingsHandler>();
     container.Register<IAsyncHandler<SearchQuerySubmittedMessage>, SearchQuerySubmittedHandler>();
     container.Register<IAsyncHandler<SetLockScreenMessage>, SetLockScreenHandler>();
     container.Register<IAsyncHandler<SaveImageMessage>, SaveImageHandler>();
 }

        public static void RegisterServices(IContainer container)
        {
            Preconditions.CheckNotNull(container, "container");

            // Note: IConnectionConfiguration gets registered when RabbitHutch.CreateBus(..) is run.

            // default service registration
            container
                .Register(_ => container)
                .Register<IEasyNetQLogger, ConsoleLogger>()
                .Register<ISerializer, JsonSerializer>()
                .Register<IConventions, Conventions>()
                .Register<IEventBus, EventBus>()
                .Register<ITypeNameSerializer, TypeNameSerializer>()
                .Register<Func<string>>(x => CorrelationIdGenerator.GetCorrelationId)
                .Register<IClusterHostSelectionStrategy<ConnectionFactoryInfo>, DefaultClusterHostSelectionStrategy<ConnectionFactoryInfo>>()
                .Register<IConsumerDispatcherFactory, ConsumerDispatcherFactory>()
                .Register<IPublishExchangeDeclareStrategy, PublishExchangeDeclareStrategy>()
                .Register(sp => PublisherFactory.CreatePublisher(sp.Resolve<IConnectionConfiguration>(), sp.Resolve<IEasyNetQLogger>(), sp.Resolve<IEventBus>()))
                .Register<IConsumerErrorStrategy, DefaultConsumerErrorStrategy>()
                .Register<IHandlerRunner, HandlerRunner>()
                .Register<IInternalConsumerFactory, InternalConsumerFactory>()
                .Register<IConsumerFactory, ConsumerFactory>()
                .Register<IConnectionFactory, ConnectionFactoryWrapper>()
                .Register<IPersistentChannelFactory, PersistentChannelFactory>()
                .Register<IClientCommandDispatcherFactory, ClientCommandDispatcherFactory>()
                .Register<IHandlerCollectionFactory, HandlerCollectionFactory>()
                .Register<IAdvancedBus, RabbitAdvancedBus>()
                .Register<IRpc, Rpc>()
                .Register<ISendReceive, SendReceive>()
                .Register<IBus, RabbitBus>();
        }