C# Container.RegisterInstance方法代码示例

        public void InterfaceReRegisteredFromInstanceToInstance_Success()
        {
            var c = new Container();
            IEmptyClass emptyClass = new EmptyClass();
            c.RegisterInstance(emptyClass).AsPerHttpContext();

            var controller = new DefaultController();
            HttpContext.Current = new HttpContext(new HttpRequest("", "http://tempuri.org", ""), new HttpResponse(new StringWriter()));
            var result1 = controller.ResolveObject<IEmptyClass>(c, ResolveKind.PartialEmitFunction);
            var emptyClass1 = (IEmptyClass)((ViewResult)result1).Model;
            var result2 = controller.ResolveObject<IEmptyClass>(c, ResolveKind.PartialEmitFunction);
            var emptyClass2 = (IEmptyClass)((ViewResult)result2).Model;

            IEmptyClass emptyClass3 = new EmptyClass();
            c.RegisterInstance(emptyClass3).AsPerHttpContext();
            var result4 = controller.ResolveObject<IEmptyClass>(c, ResolveKind.PartialEmitFunction);
            var emptyClass4 = (IEmptyClass)((ViewResult)result4).Model;
            var result5 = controller.ResolveObject<IEmptyClass>(c, ResolveKind.PartialEmitFunction);
            var emptyClass5 = (IEmptyClass)((ViewResult)result5).Model;

            Assert.AreEqual(emptyClass, emptyClass1);
            Assert.AreEqual(emptyClass1, emptyClass2);
            Assert.AreEqual(emptyClass3, emptyClass4);
            Assert.AreEqual(emptyClass4, emptyClass5);
            Assert.AreNotEqual(emptyClass, emptyClass3);
        }

 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 T02_Interface()
 {
     var container = new Container(log: Write);
     var instance = new SomeClass();
     container.RegisterInstance<ISomeClass>(instance);
     var instance1 = container.Resolve<ISomeClass>();
     Assert.Equal(instance, instance1);
     var instance2 = container.Resolve<ISomeClass>();
     Assert.Equal(instance1, instance2);
     Assert.Throws<TypeAccessException>(() => container.Resolve<SomeClass>());
     Assert.Throws<TypeAccessException>(() => container.RegisterInstance<ISomeClass>(instance)).WriteMessageTo(Write);
 }

        public void Register2Instances()
        {
            var container = new Container();
            var a = new ClassA();
            container.RegisterInstance(a, "A");
            var b = new ClassA();
            container.RegisterInstance(b, "B");

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

        public void MainMenuInvisibleAfterFlightStarted()
        {
            var mainMenu = new Mock<IMainMenu>();

            var container = new Container();
            container.RegisterType<GameMain>();
            container.RegisterInstance(mainMenu.Object);
            container.RegisterInstance(new Mock<IHud>().Object);
            container.RegisterInstance(new Mock<IFlight>().Object);

            var gameMain = container.Resolve<GameMain>();
            mainMenu.Raise(m => m.StartNewGame += null);
            mainMenu.Verify(m => m.SetVisible(false), Times.Once());
        }

        public void FlightNotUpdated()
        {
            var flight = new Mock<IFlight>();

            var container = new Container();
            container.RegisterType<GameMain>();
            container.RegisterInstance(new Mock<IMainMenu>().Object);
            container.RegisterInstance(new Mock<IHud>().Object);
            container.RegisterInstance(flight.Object);

            var gameMain = container.Resolve<GameMain>();
            gameMain.Update(1.0f);
            flight.Verify(f => f.StartNewFlight(), Times.Never());
            flight.Verify(f => f.Update(It.IsAny<float>()), Times.Never());
        }

        public void ClassReRegisteredFromClassToInstance_Success()
        {
            var c = new Container();
            c.RegisterType<EmptyClass>().AsPerThread();
            var emptyClass = new EmptyClass();
            EmptyClass emptyClass1 = null;
            EmptyClass emptyClass2 = null;
            EmptyClass emptyClass3 = null;
            EmptyClass emptyClass4 = null;

            var thread = new Thread(() =>
            {
                emptyClass1 = c.Resolve<EmptyClass>(ResolveKind.PartialEmitFunction);
                emptyClass2 = c.Resolve<EmptyClass>(ResolveKind.PartialEmitFunction);

                c.RegisterInstance(emptyClass).AsPerThread();
                emptyClass3 = c.Resolve<EmptyClass>(ResolveKind.PartialEmitFunction);
                emptyClass4 = c.Resolve<EmptyClass>(ResolveKind.PartialEmitFunction);
            });
            thread.Start();
            thread.Join();

            Assert.AreEqual(emptyClass1, emptyClass2);
            Assert.AreEqual(emptyClass, emptyClass3);
            Assert.AreEqual(emptyClass3, emptyClass4);
            Assert.AreNotEqual(emptyClass1, emptyClass);
        }

        public void InterfaceReRegisteredFromInstanceToInstance_Success()
        {
            var c = new Container();
            IEmptyClass emptyClass = new EmptyClass();
            IEmptyClass emptyClass3 = new EmptyClass();
            c.RegisterInstance(emptyClass).AsPerThread();
            IEmptyClass emptyClass1 = null;
            IEmptyClass emptyClass2 = null;
            IEmptyClass emptyClass4 = null;
            IEmptyClass emptyClass5 = null;

            var thread = new Thread(() =>
            {
                emptyClass1 = c.Resolve<IEmptyClass>(ResolveKind.FullEmitFunction);
                emptyClass2 = c.Resolve<IEmptyClass>(ResolveKind.FullEmitFunction);

                c.RegisterInstance(emptyClass3).AsPerThread();
                emptyClass4 = c.Resolve<IEmptyClass>(ResolveKind.FullEmitFunction);
                emptyClass5 = c.Resolve<IEmptyClass>(ResolveKind.FullEmitFunction);
            });
            thread.Start();
            thread.Join();

            Assert.AreEqual(emptyClass, emptyClass1);
            Assert.AreEqual(emptyClass1, emptyClass2);
            Assert.AreEqual(emptyClass3, emptyClass4);
            Assert.AreEqual(emptyClass4, emptyClass5);
            Assert.AreNotEqual(emptyClass, emptyClass3);
        }

        public void StartNewFlightPropagated()
        {
            var field = new Mock<IAsteroidField>();
            var shipController = new Mock<IShipController>();

            var container = new Container();
            container.RegisterType<Flight>();
            container.RegisterInstance(field.Object);
            container.RegisterInstance(new Mock<ISpaceShip>().Object);
            container.RegisterInstance(shipController.Object);

            var flight = container.Resolve<Flight>();
            flight.StartNewFlight();
            field.Verify(f => f.StartNewFlight(),Times.Once());
            shipController.Verify(s => s.StartNewFlight(),Times.Once());
        }

 public void T02_Dispose_Instance()
 {
     var container = new Container(defaultLifestyle: DefaultLifestyle.Singleton, log: Write);
     var instance = new ClassA();
     container.RegisterInstance(instance);
     container.Dispose();
     Assert.True(instance.IsDisposed);
 }

        public void FlightStartedFromMainMenu()
        {
            var mainMenu = new Mock<IMainMenu>();
            var flight = new Mock<IFlight>();

            var container = new Container();
            container.RegisterType<GameMain>();
            container.RegisterInstance(mainMenu.Object);
            container.RegisterInstance(new Mock<IHud>().Object);
            container.RegisterInstance(flight.Object);

            var gameMain = container.Resolve<GameMain>();
            mainMenu.Raise(m => m.StartNewGame += null);

            flight.Verify(f => f.StartNewFlight(), Times.Once());
            gameMain.Update(1.0f);
            flight.Verify(f => f.Update(1.0f), Times.Once());
        }

        public void RegisterInstanceOfEmptyClass_Success()
        {
            var c = new Container();
            var emptyClass1 = new EmptyClass();
            c.RegisterInstance(emptyClass1);

            var emptyClass2 = c.Resolve<EmptyClass>(ResolveKind.FullEmitFunction);

            Assert.AreEqual(emptyClass1, emptyClass2);
        }

        public void Should_return_registered_instance_per_interface()
        {
            IContainer c = new Container();
            ITestClass instance = new TestClass();
            c.RegisterInstance<ITestClass>(instance);

            var result = c.Resolve<ITestClass>();

            Assert.AreSame(instance, result);
        }

        public void RegisterInstance()
        {
            var container = new Container();
            var a = new ClassA();
            container.RegisterInstance(a);

            var b = container.Resolve<ClassA>();
            Assert.IsNotNull(a);
            Assert.AreSame(a, b);
        }

        public void InstanceInjectedNotCalled()
        {
            var container = new Container();
            var a = new Dependent();
            container.RegisterInstance(a);

            var b = container.Resolve<Dependent>();
            Assert.AreEqual(0, a.OnInjectedCalledCount);
            Assert.AreEqual(0, b.OnInjectedCalledCount);
        }