C# Container.RegisterSingleton方法代码示例

        public void Register(Container container)
        {
            container.RegisterSingleton(() =>
            {
                LicenseUtils.RegisterLicense("2283-e1JlZjoyMjgzLE5hbWU6TWVkWENoYW5nZSxUeXBlOkluZGllLEhhc2g6TU" +
                "FyaTVzNGdQcEdlc0pqd1ZIUXVlL0lacDBZcCt3TkFLY0UyMTlJblBuMzRLNWFRb" +
                "HBYN204aGkrQXlRYzUvZnNVUlZzWXd4NjR0OFlXZEpjNUNYRTdnMjBLR0ZjQmhG" +
                "dTFNMHZVazJqcHdQb1RrbStDaHNPRm11Qm50TnZzOTkwcHAzRkxtTC9idThMekN" +
                "lTVRndFBORzBuREZ0WGJUdzdRMi80K09lQ2tZPSxFeHBpcnk6MjAxNi0wMi0xOX" +
                "0=");

                var rabbitMqHost = ConfigurationManager.AppSettings["RabbitMQHost"];
                if (string.IsNullOrEmpty(rabbitMqHost)) throw new Exception("You must provide a 'RabbitMQHost' app setting.");
                return new RabbitMqServer(rabbitMqHost)
                {
                    ErrorHandler = exception =>
                    {
                        Logger.For<RabbitMqServer>().Error("There was an error processing a message.", exception);
                    }
                };
            });
            container.RegisterSingleton<ICommandBus, CommandBus>();
            container.RegisterSingleton<IEventBus, EventBus>();
            container.RegisterSingleton<IBusLifetime, BusLifetime>();
        }

        private static Container ConfigureContainer()
        {
            var container = new Container();

              // Reset this line to reconfigure for production
              container.RegisterSingleton<ISettingsService>(new TestSettingsService());
              //container.RegisterSingleton<ISettingsService>(new ProductionSettingsService());

              container.Register<ILogger, NlogLoggerAdapter>();
              container.RegisterSingleton<IPlantPhotoService, PlantPhotoService>();
              container.RegisterSingleton<IImageRenameService, ImageRenameService>();
              container.RegisterSingleton<IRenameOperationsManager, RenameOperationsManager>();

              container.RegisterInitializer<IImageRenameService>(svc =>
              {
            svc.Logger = new NlogLoggerAdapter(LogManager.GetLogger("logFile"));
              });

              container.RegisterInitializer<IRenameOperationsManager>(mgr =>
              {
            mgr.ConsoleLogger = new NlogLoggerAdapter(LogManager.GetLogger("logConsole"));
              });

              return container;
        }

        static void Main(string[] args)
        {
            var container = new Container();
            RegisterInfrastructure(container);
            var assemblies = GetAssemblies().ToArray();
            container.RegisterSingleton<IMediator, Mediator>();
            container.RegisterSingleton(new SingleInstanceFactory(container.GetInstance));
            container.RegisterSingleton(new MultiInstanceFactory(container.GetAllInstances));
            container.RegisterCollection(typeof(IAsyncNotificationHandler<>), assemblies);
            container.Verify();

            var mediator = container.GetInstance<IMediator>();
            var commandsDbContext = container.GetInstance<ICommandsDbContext>();

            Console.Write("creating users...");
            Task.WaitAll(CreateUsersAsync(commandsDbContext, mediator));
            Console.WriteLine("done!");

            Console.Write("creating areas...");
            Task.WaitAll(CreateAreasAsync(commandsDbContext, mediator));
            Console.WriteLine("done!");

            Console.Write("creating ideas...");
            Task.WaitAll(CreateIdeasAsync(commandsDbContext, mediator));
            Console.WriteLine("done!");

            Console.Write("creating idea comments...");
            Task.WaitAll(CreateIdeaCommentsAsync(commandsDbContext, mediator));
            Console.WriteLine("done!");

            Console.WriteLine("Feeding complete!");
            Console.ReadLine();
        }

 public void Configure(Container container)
 {
     container.RegisterSingleton<IUserRepository, UserRespository>();
     container.RegisterSingleton<IShoppingItemRepository, ShoppingItemRepository>();
     container.RegisterSingleton<IShoppingListRepository, ShoppingListRepository>();
     container.RegisterSingleton<IFriendRepository, FriendRepository>();
 }

        public void RegisterServices(Container container)
        {
            container.RegisterSingleton<IConfiguration, EnvironmentAwareAppSettingsConfiguration>();
            container.RegisterSingleton(() =>
            {
                var config = container.GetInstance<IConfiguration>();
                var useRedis = config.Get("UseRedis");

                IDataServiceFactory factory;

                if (bool.Parse(useRedis))
                {
                    factory = new RedisDataServiceFactory(config);
                }
                else
                {
                    factory = new DirectDataServiceFactory();
                }

                return factory;
            });

            container.RegisterSingleton(() => container.GetInstance<IDataServiceFactory>().Create());
            container.RegisterSingleton<IAppSettings, AppSettings>();
        }

		public static void InitializeFruit(Container container)
		{
			container.RegisterSingleton<IFruitsFactory, FruitsFactory>();
			container.RegisterSingleton<IFruitItemRepository, FruitItemRepository>();
			container.RegisterSingleton<IFruitListViewModelFactory, FruitListViewModelFactory>();
			container.RegisterSingleton<IFruitListItemViewModelFactory, FruitListItemViewModelFactory>();
		}

 public void Register(Container container)
 {
     container.RegisterSingleton<IMapper, Mapper>();
     container.RegisterSingleton<IConnectionStringProvider, ConnectionStringProvider>();
     container.RegisterSingleton<IDbConnectionProvider, SqlConnectionProvider>();
     container.RegisterSingleton<IEmailSender, EmailSender>();
     container.RegisterSingleton<IPathResolver, PathResolver>();
 }

 private static Container ConfigureIoc()
 {
     var container = new Container();
     container.RegisterSingleton(() => new RemoteClientListenerFactory().Build());
     container.RegisterSingleton<CommandLineProcessor>();
     container.RegisterSingleton<ICommandLineHandlerLocator>(() => new CommandLineHandlerLocator(container));
     container.RegisterSingleton<Context>();
     container.RegisterSingleton<ClientList>();
     return container;
 }

 private static void IocSetup(Container container)
 {
     var assemblies = GetAssemblies().ToArray();
     
     container.RegisterSingleton<IMediator, Mediator>();
     container.RegisterSingleton<ILog, Log>();
     container.Register(typeof(IQueryHandler<,>), assemblies);
     container.RegisterCollection(typeof(IQueryHandler<,>), assemblies);
     container.RegisterSingleton(typeof(DbContext), new DbEntities());
 }

        protected override void OnStart(string[] args)
        {
            _container = new Container();

            _container.RegisterSingleton<IAchievementPushService, AchievementPushService>();
            _container.RegisterSingleton<IAchievementService, AchievementService>();
            _container.RegisterSingleton<IActivityGroupingService, ActivityGroupingService>();
            _container.RegisterSingleton<IDatabaseService, DatabaseService>();
            _container.RegisterSingleton<IFitocracyService, FitocracyService>();
            _container.RegisterSingleton<IScrapingService, ScrapingService>();
            _container.RegisterSingleton<IUserPullService, UserPullService>();
            _container.RegisterSingleton<IWebRequestService, WebRequestService>();
            _container.RegisterSingleton<IWorkoutPullService, WorkoutPullService>();

            _container.RegisterCollection<IAchievementProvider>(
                GetType().Assembly.GetTypes()
                         .Where(typeof (IAchievementProvider).IsAssignableFrom)
                         .Where(type => type.IsClass));

            _container.RegisterDecorator<IWebRequestService, ThrottledWebRequestDecorator>(Lifestyle.Singleton);

            _container.Verify();

            _cancelSource = new CancellationTokenSource();
            _task = Task.Factory.StartNew(Run, _cancelSource.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
        }

        public DomainTestHarness()
        {
            _container = new Container();
             _container.RegisterSingleton<IApplicationSettings>(new Mock<IApplicationSettings>().Object);
             _container.RegisterSingleton<IAnalyticsRepository<Contact>>(() => new Mock<IAnalyticsRepository<Contact>>().Object);
             _container.RegisterSingleton<IAnalyticsRepository<Interaction>>(() => new Mock<IAnalyticsRepository<Interaction>>().Object);
             _container.RegisterSingleton<IContactService, xDBContactService>();
             _container.RegisterSingleton<IInteractionService, xDBInteractionService>();

             _fixture = new Fixture();
        }

        public static void RegisterDependencies()
        {
            var container = new Container {Options = {DefaultScopedLifestyle = new WebRequestLifestyle()}};

            // Container
            container.Register<IServiceProvider>(() => container);

            // Request (command/query) dispatcher
            container.Register<IRequestDispatcher, RequestDispatcher>();

            // Command handlers
            container.Register(typeof (ICommandHandler<>), new[] {typeof (TabService).Assembly});
            container.RegisterDecorator(typeof (ICommandHandler<>), typeof (ValidationDecoratorCommandHandler<>));
            container.RegisterDecorator(typeof (ICommandHandler<>), typeof (LoggingDecoratorCommandHandler<>));

            // Query handlers
            container.Register(typeof (IQueryHandler<,>), new[] {typeof (TabReadModel).Assembly});

            // Validators
            container.RegisterSingleton(typeof (IValidator<>), typeof (CompositeValidator<>));
            container.AppendToCollection(typeof (IValidator<>), typeof (DataAnnotationsValidator<>));
            container.RegisterCollection(typeof (IValidator<>), typeof (MvcApplication).Assembly);

            // Data annotations validators
            container.Register(typeof (IValidationAttributeValidator<>), new[] {typeof (IValidationAttributeValidator<>).Assembly});

            // Loggers
            container.RegisterSingleton<ILoggerFactory, NLogLoggerFactory>();

            // Action filters
            container.RegisterCollection(typeof (IActionFilter<>), typeof (MvcApplication).Assembly);

            // Repository
            container.Register<IEventStore, InMemoryEventStore>();

            // Aggregate factory
            container.Register<IAggregateFactory, AggregateFactory>();

            // Event publisher
            container.Register<IEventPublisher>(() => new EventPublisher(type => container.GetAllInstances(type), container.GetInstance<ILoggerFactory>()));

            // Event handlers
            container.RegisterCollection(typeof (IEventSubscriber<>), new[] {typeof (TabReadModel).Assembly});

            // View model database
            container.RegisterSingleton<IReadModelDatabase, InMemoryReadModelDatabase>();

            // Verify
            container.Verify();

            System.Web.Mvc.DependencyResolver.SetResolver(new SimpleInjectorDependencyResolver(container));
            System.Web.Mvc.GlobalFilters.Filters.Add(new ActionFilterDispatcher(type => container.GetAllInstances(type)));
            ServiceProvider = container;
        }

        /// <summary>
        /// Configure the runtime dependencies
        /// </summary>
        protected override void Configure()
        {
            //Check database:
            Db.ConfigureMigrations();

            container = new Container();

            container.RegisterSingleton<IWindowManager, WindowManager>();
            container.RegisterSingleton<IEventAggregator, EventAggregator>();
            container.Register<IShell, ShellViewModel>();
            container.RegisterSingleton<Func<Db>>(() => new Db());
        }

        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();

            WebApiConfig.Register(GlobalConfiguration.Configuration);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BootstrapBundleConfig.RegisterBundles();

            var container = new Container();

            container.Options.DefaultScopedLifestyle = new WebRequestLifestyle();

            container.RegisterSingleton<ILinqToLdapLogger>(new SimpleTextLogger());

            container.RegisterSingleton<ILdapConfiguration>(() =>
            {
                var config = new LdapConfiguration()
                    .MaxPageSizeIs(50)
                    .LogTo(container.GetInstance<ILinqToLdapLogger>());

                //Note the optional parameters available on AddMapping.
                //We can perform "late" mapping on certain values, 
                //even for auto and attribute based mapping.
                config.AddMapping(new OrganizationalUnitMap())
                      .AddMapping(new AttributeClassMap<User>());

                // I explicitly mapped User, but I can also let it 
                // get mapped the first time we query for users.
                // This only applies to auto and attribute-based mapping.

                config.ConfigurePooledFactory("directory.utexas.edu")
                      .AuthenticateBy(AuthType.Anonymous)
                      .MinPoolSizeIs(0)
                      .MaxPoolSizeIs(5)
                      .UsePort(389)
                      .ProtocolVersion(3);

                return config;
            });

            //simple context per request only when requested
            container.Register<IDirectoryContext>(() => container.GetInstance<ILdapConfiguration>().CreateContext(), Lifestyle.Scoped);

            container.RegisterWebApiControllers(GlobalConfiguration.Configuration);
            container.RegisterMvcControllers(Assembly.GetExecutingAssembly());
            

            GlobalConfiguration.Configuration.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);
            DependencyResolver.SetResolver(new SimpleInjectorDependencyResolver(container));
            
            container.Verify();
        }

        protected override IServiceProvider BootstrapInternal(ILoggerFactory loggerFactory) {
            var container = new Container();

            if (loggerFactory != null) {
                container.RegisterSingleton<ILoggerFactory>(loggerFactory);
                container.RegisterSingleton(typeof(ILogger<>), typeof(Logger<>));
            }

            container.RegisterSingleton<ICacheClient>(() => new InMemoryCacheClient());
            container.RegisterSingleton<ILockProvider>(() => new CacheLockProvider(container.GetInstance<ICacheClient>(), container.GetInstance<IMessageBus>(), loggerFactory));

            return container;
        }