C# Container.RegisterSingleton方法代码示例

 public void Test_CaptiveDependency_Singleton_Singleton()
 {
     var container = new Container(log: Write);
     container.RegisterSingleton<ClassA>();
     container.RegisterSingleton<ClassB>();
     container.Resolve<ClassA>();
 }

 public void T03_Concrete_Interface()
 {
     var container = new Container(log: Write);
     container.RegisterSingleton<ISomeClass>();
     container.RegisterSingleton<SomeClass>();
     Assert.Equal(container.Resolve<SomeClass>(), container.Resolve<ISomeClass>());
 }

        public void Initialize(HttpConfiguration configuration, Pandora pandora)
        {
            var container = new Container();
            container.RegisterSingleton<Pandora>(() => pandora);
            Func<IPipelineTransport> transport = () => container.Resolve<IPipelineTransport>();
            Func<ISerializer> serializer = () => container.Resolve<ISerializer>();
            container.RegisterSingleton<IPublisher<ICommand>>(() => new PipelinePublisher<ICommand>(transport(), serializer()));

            var serviceLocator = new ServiceLocator(container);
            ControllerFactory = new ServiceLocatorFactory(serviceLocator);

            var cfg = new CronusSettings(container)
                  .UseCluster(cluster =>
                       cluster.UseAggregateRootAtomicAction(atomic =>
                       {
                           if (pandora.Get<bool>("enable_redis_atomic_action"))
                               atomic.UseRedis(redis => redis.SetLockEndPoints(pandora.Get("redis_endpoints").ParseIPEndPoints(";")));
                           else
                               atomic.WithInMemory();
                       }))
                  .UseContractsFromAssemblies(new[] { Assembly.GetAssembly(typeof(PushNotificationWasSent)) })
                  .UseRabbitMqTransport(x =>
                  {
                      x.Server = pandora.Get("rabbitmq_server");
                      x.Username = pandora.Get("rabbitmq_username");
                      x.Password = pandora.Get("rabbitmq_password");
                      x.VirtualHost = pandora.Get("rabbitmq_virtualhost");
                  });

            (cfg as ICronusSettings).Build();
        }

 public void Test_Multiple2()
 {
     var container = new Container(log: Write);
     container.RegisterSingleton<Foo>();
     container.RegisterSingleton<IFoo1>();
     Assert.Equal(container.Resolve<Foo>(), container.Resolve<IFoo1>());
 }

 public void T04_Register_Singleton()
 {
     var container = new Container(log: Write);
     container.RegisterSingleton<ISomeClass, SomeClass>();
     Assert.Throws<TypeAccessException>(() => container.Resolve<SomeClass>()).WriteMessageTo(Write);
     container.RegisterSingleton<SomeClass>();
     Assert.Equal(container.Resolve<ISomeClass>(), container.Resolve<SomeClass>());
 }

        public void Register2Named()
        {
            var container = new Container();
            container.RegisterSingleton<ClassA>("A");
            container.RegisterSingleton<ClassA>("B");

            var a = container.Resolve<ClassA>("A");
            var b = container.Resolve<ClassA>("B");
            Assert.AreNotSame(a, b);
        }

        public void T01_Duplicate_Registration()
        {
            var container = new Container(DefaultLifestyle.Singleton, log: Write);

            container.RegisterSingleton<ClassA1>();
            Assert.Throws<TypeAccessException>(() => container.RegisterSingleton<ClassA1>()).WriteMessageTo(Write);

            container.RegisterSingleton<IMarker1, ClassA2>();
            Assert.Throws<TypeAccessException>(() => container.RegisterSingleton<IMarker1, ClassA2>()).WriteMessageTo(Write);
        }

 public void T00_Various_types()
 {
     var container = new Container(log: Write);
     Assert.Throws<ArgumentNullException>(() => container.RegisterSingleton(null)).WriteMessageTo(Write);
     Assert.Throws<ArgumentNullException>(() => container.RegisterFactory(typeof(object), null)).WriteMessageTo(Write);
     Assert.Throws<ArgumentNullException>(() => container.RegisterInstance(typeof(object), null)).WriteMessageTo(Write);
     Assert.Throws<TypeAccessException>(() => container.RegisterSingleton(typeof(int))).WriteMessageTo(Write);
     Assert.Throws<TypeAccessException>(() => container.RegisterSingleton(typeof(string))).WriteMessageTo(Write);
     Assert.Throws<TypeAccessException>(() => container.RegisterInstance(42)).WriteMessageTo(Write);
     Assert.Throws<ArgumentNullException>(() => container.Resolve(null)).WriteMessageTo(Write);
 }

 public void T03_Registration_Concrete_Multiple()
 {
     var container = new Container(log: Write);
     container.RegisterSingleton<IMarker1, ClassA1>();
     container.Resolve<IMarker1>();
     Assert.Throws<TypeAccessException>(() => container.Resolve<ClassA1>()).WriteMessageTo(Write);
 }

        public void InterceptWithGenericArgAndPredicate_TwoInterceptors_InterceptsTheInstanceWithBothInterceptors()
        {
            // Arrange
            var logger = new FakeLogger();

            var container = new Container();

            container.RegisterSingleton<ILogger>(logger);
            container.Register<ICommand, CommandThatLogsOnExecute>();

            container.InterceptWith<InterceptorThatLogsBeforeAndAfter>(IsACommandPredicate);
            container.InterceptWith<InterceptorThatLogsBeforeAndAfter2>(IsACommandPredicate);

            container.RegisterInitializer<InterceptorThatLogsBeforeAndAfter>(i => i.BeforeText = "Start1 ");
            container.RegisterInitializer<InterceptorThatLogsBeforeAndAfter2>(i => i.BeforeText = "Start2 ");
            container.RegisterInitializer<CommandThatLogsOnExecute>(c => c.ExecuteLogMessage = "Executing");
            container.RegisterInitializer<InterceptorThatLogsBeforeAndAfter>(i => i.AfterText = " Done1");
            container.RegisterInitializer<InterceptorThatLogsBeforeAndAfter2>(i => i.AfterText = " Done2");
            
            // Act
            var command = container.GetInstance<ICommand>();

            command.Execute();

            // Assert
            Assert.AreEqual("Start2 Start1 Executing Done1 Done2", logger.Message);
        }

        public void Intercept_CollectionWithRegistrationInstances_InterceptsTheInstances()
        {
            var logger = new FakeLogger();

            var container = new Container();

            container.RegisterSingleton<ILogger>(logger);
            container.RegisterCollection<ICommand>(new[] 
            {
                Lifestyle.Transient.CreateRegistration(typeof(ICommand), typeof(ConcreteCommand), container),
                Lifestyle.Transient.CreateRegistration(typeof(ConcreteCommand), container),
            });

            container.InterceptWith<InterceptorThatLogsBeforeAndAfter>(IsACommandPredicate);

            container.RegisterInitializer<InterceptorThatLogsBeforeAndAfter>(i => i.BeforeText = "Log ");

            // Act
            var commands = container.GetAllInstances<ICommand>().ToList();

            commands.ForEach(Execute);

            // Assert
            Assert.AreEqual("Log Log ", logger.Message);
        }

 public void T02()
 {
     var container = new Container(defaultLifestyle: DefaultLifestyle.Singleton, log: Write, assemblies: typeof(string).Assembly);
     container.RegisterSingleton<IClassA, ClassA>();
     Write("");
     container.Log();
 }

 public void Test_CaptiveDependency_Singleton_Transient()
 {
     var container = new Container(log: Write);
     container.RegisterSingleton<ClassA>();
     container.RegisterTransient<ClassB>();
     Assert.Throws<TypeAccessException>(() => container.Resolve<ClassA>()).WriteMessageTo(Write);
 }

 public static void Main()
 {
     var container = new Container();
     container.RegisterSingleton<IFoo, Foo>();
     IFoo foo = container.Resolve<IFoo>();
     // ...
 }

 public void T05_Duplicate_Concrete_Interface()
 {
     var container = new Container(log: Write);
     container.RegisterSingleton<ISomeClass, SomeClass>();
     container.RegisterSingleton<SomeClass>();
     Assert.Throws<TypeAccessException>(() => container.RegisterSingleton<SomeClass>()).WriteMessageTo(Write);
 }