public ResolveType ( |
||
serviceType | The type of the service. | |
tag | object | The tag to register the service with. The default value is |
return | object |
public void ThrowsArgumentExceptionForNullTypes() { var serviceLocator = new ServiceLocator(); var dependencyResolver = serviceLocator.ResolveType<IDependencyResolver>(); ExceptionTester.CallMethodAndExpectException<ArgumentException>(() => dependencyResolver.CanResolveAll(null)); }
public void ReturnsTrueForEmptyArray() { var serviceLocator = new ServiceLocator(); var dependencyResolver = serviceLocator.ResolveType<IDependencyResolver>(); Assert.IsTrue(dependencyResolver.CanResolveAll(new Type[] { })); }
public void ReturnsFalseForNonRegisteredType() { var serviceLocator = new ServiceLocator(); var dependencyResolver = serviceLocator.ResolveType<IDependencyResolver>(); Assert.IsFalse(dependencyResolver.CanResolve(typeof(IMessageService))); }
public void ReturnsTypeFactoryUsedToCreateObject() { var serviceLocator = new ServiceLocator(); var typeFactory = serviceLocator.ResolveType<ITypeFactory>(); var obj = typeFactory.CreateInstance<object>(); var usedTypeFactory = obj.GetTypeFactory(); Assert.IsTrue(ReferenceEquals(typeFactory, usedTypeFactory)); }
public void ReturnsDependencyResolverUsedToCreateObject() { var serviceLocator = new ServiceLocator(); var dependencyResolver = serviceLocator.ResolveType<IDependencyResolver>(); var typeFactory = dependencyResolver.Resolve<ITypeFactory>(); var obj = typeFactory.CreateInstance<object>(); var usedDependencyResolver = obj.GetDependencyResolver(); Assert.IsTrue(ReferenceEquals(dependencyResolver, usedDependencyResolver)); }
public void ResolvesTypeUsingDependencyInjectionFallBackToDefaultConstructor() { var serviceLocator = new ServiceLocator(); var typeFactory = serviceLocator.ResolveType<ITypeFactory>(); var instance = typeFactory.CreateInstance<DependencyInjectionTestClass>(); Assert.IsTrue(instance.UsedDefaultConstructor); }
public void CallsCustomInitializationWhenNeeded() { var serviceLocator = new ServiceLocator(); var typeFactory = serviceLocator.ResolveType<ITypeFactory>(); var instance = typeFactory.CreateInstance<DependencyInjectionTestClass>(); Assert.IsTrue(instance.HasCalledCustomInitialization); }
public void TheOpenedActionIsCalledEvenWhenThereNoViewsAvailablesInTheExpectedTimeForTheCurrentViewModelButUnlockingTheInspectionThread() { var serviceLocator = new ServiceLocator(); var fooViewModel = new FooViewModel(serviceLocator); var dispatcherServiceMock = new Mock<IDispatcherService>(); dispatcherServiceMock.Setup(service => service.Invoke(It.IsAny<Action>())).Callback((Action action) => action.Invoke()); var visualizerServiceMock = new Mock<IUIVisualizerService>(); visualizerServiceMock.Setup(service => service.Show(It.Is<FooViewModel>(model => ReferenceEquals(model, fooViewModel)), null)).Returns(true); var viewManagerMock = new Mock<IViewManager>(); viewManagerMock.Setup(manager => manager.GetViewsOfViewModel(fooViewModel)).Returns(new IView[] { }); serviceLocator.RegisterInstance<IDispatcherService>(dispatcherServiceMock.Object); serviceLocator.RegisterInstance<IUIVisualizerService>(visualizerServiceMock.Object); serviceLocator.RegisterInstance<IViewManager>(viewManagerMock.Object); var @event = new AutoResetEvent(false); serviceLocator.ResolveType<IUIVisualizerService>().Show(fooViewModel, () => @event.Set()); @event.WaitOne(20000); visualizerServiceMock.Verify(service => service.Show(It.Is<FooViewModel>(model => ReferenceEquals(model, fooViewModel)), null), Times.Once()); viewManagerMock.Verify(manager => manager.GetViewsOfViewModel(fooViewModel), Times.AtLeastOnce()); }
public void RegistersTheImplementationTypesAsInterfaceTypesIfIsSetToTrue() { var serviceLocator = new ServiceLocator { AutoRegisterTypesViaAttributes = true }; Assert.IsTrue(serviceLocator.IsTypeRegistered<IFooService>()); Assert.IsTrue(serviceLocator.IsTypeRegisteredAsSingleton<IFooService>()); Assert.IsTrue(serviceLocator.IsTypeRegistered<IFooService2>()); Assert.IsFalse(serviceLocator.IsTypeRegisteredAsSingleton<IFooService2>()); var resolveType = serviceLocator.ResolveType<IFooService>(); Assert.IsInstanceOfType(resolveType, typeof(FooService)); var resolveType2 = serviceLocator.ResolveType<IFooService2>(); Assert.IsInstanceOfType(resolveType2, typeof(FooService2)); }
public void AutomaticSynchronization_ResolveType() { var serviceLocator = new ServiceLocator(); serviceLocator.AutomaticallyKeepContainersSynchronized = false; serviceLocator.RegisterType<ITestInterface, TestClass1>(); var ninjectContainer = new StandardKernel(); serviceLocator.RegisterExternalContainer(ninjectContainer); serviceLocator.AutomaticallyKeepContainersSynchronized = true; serviceLocator.ResolveType<ITestInterface>(); Assert.IsTrue(ninjectContainer.GetBindings(typeof(ITestInterface)).Any()); }
public void ResolveType_RegisteredInExternalContainer() { var serviceLocator = new ServiceLocator(); var ninjectContainer = new StandardKernel(); serviceLocator.RegisterExternalContainer(ninjectContainer); ninjectContainer.Bind<ITestInterface>().To<TestClass1>(); var instance = serviceLocator.ResolveType<ITestInterface>(); Assert.IsInstanceOfType(instance, typeof(TestClass1)); }
public void RegisterType_DoubleRegistration_ToChangeInstantiationStyle_And_Type() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterType<ITestInterface, TestClass1>(); var testInterfaceRef1 = serviceLocator.ResolveType<ITestInterface>(); var testInterfaceRef2 = serviceLocator.ResolveType<ITestInterface>(); Assert.AreSame(testInterfaceRef1, testInterfaceRef2); Assert.AreEqual(testInterfaceRef2.GetType(), typeof(TestClass1)); serviceLocator.RegisterType<ITestInterface, TestClass2>(registrationType: RegistrationType.Transient); testInterfaceRef1 = serviceLocator.ResolveType<ITestInterface>(); testInterfaceRef2 = serviceLocator.ResolveType<ITestInterface>(); Assert.AreNotSame(testInterfaceRef1, testInterfaceRef2); Assert.AreEqual(testInterfaceRef2.GetType(), typeof(TestClass2)); }
public void RegisterInstance_Valid() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterInstance<ITestInterface>(new TestClass1 { Name = "My Instance" }); Assert.IsTrue(serviceLocator.IsTypeRegistered<ITestInterface>()); var instance = serviceLocator.ResolveType<ITestInterface>(); Assert.AreEqual("My Instance", instance.Name); }
public void OverridesRegistrationWithSameTag() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterType(typeof(ITestInterface), typeof(TestClass1), "1"); serviceLocator.RegisterType(typeof(ITestInterface), typeof(TestClass1), "2"); serviceLocator.RegisterType(typeof(ITestInterface), typeof(TestClass2), "1"); var firstService = serviceLocator.ResolveType(typeof(ITestInterface), "1"); Assert.AreEqual(typeof(TestClass2), firstService.GetType()); }
public void RemovesAllInstances() { var serviceLocator = new ServiceLocator { AutoRegisterTypesViaAttributes = true }; serviceLocator.RegisterType(typeof(IFoo2Service), typeof(Foo2Service), "FooService2"); var instance1 = serviceLocator.ResolveType(typeof(IFooService), "FooService1"); var instance2 = serviceLocator.ResolveType(typeof(IFooService), "FooService2"); var instance3 = serviceLocator.ResolveType(typeof(IFoo2Service), "FooService2"); serviceLocator.RemoveAllInstances(); Assert.AreNotEqual(instance1, serviceLocator.ResolveType(typeof(IFooService), "FooService1")); Assert.AreNotEqual(instance2, serviceLocator.ResolveType(typeof(IFooService), "FooService2")); Assert.AreNotEqual(instance3, serviceLocator.ResolveType(typeof(IFoo2Service), "FooService2")); }
public void ResolveType_RegisteredAsInstanceInServiceLocator() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterInstance<ITestInterface>(new TestClass2 { Name = "instance test" }); var instance = serviceLocator.ResolveType<ITestInterface>(); Assert.AreEqual("instance test", instance.Name); instance.Name = "changed name"; var newInstance = serviceLocator.ResolveType<ITestInterface>(); Assert.AreEqual("changed name", newInstance.Name); Assert.AreEqual(instance, newInstance); Assert.IsTrue(object.ReferenceEquals(instance, newInstance)); }
public void ResolveType_RegisteredAsTypeInServiceLocator() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterType<ITestInterface, TestClass1>(); var instance = serviceLocator.ResolveType<ITestInterface>(); Assert.IsInstanceOfType(instance, typeof(TestClass1)); }
public void ResoleType_Of_Non_Registered_Non_Abstract_Class_Without_Registration() { var serviceLocator = new ServiceLocator(); var dependencyInjectionTestClass = serviceLocator.ResolveType<DependencyInjectionTestClass>(); Assert.IsNotNull(dependencyInjectionTestClass); Assert.IsFalse(serviceLocator.IsTypeRegistered(typeof(DependencyInjectionTestClass))); }
public void ResolvesTypeUsingDependencyInjectionFallBackToDefaultConstructor() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterType<DependencyInjectionTestClass, DependencyInjectionTestClass>(); var instance = serviceLocator.ResolveType<DependencyInjectionTestClass>(); Assert.IsTrue(instance.UsedDefaultConstructor); }
public void ResoleType_Of_Non_Registered_Non_Abstract_Class_Without_Registration_CanResolveNonAbstractTypesWithoutRegistration_In_False() { var serviceLocator = new ServiceLocator(); serviceLocator.CanResolveNonAbstractTypesWithoutRegistration = false; ExceptionTester.CallMethodAndExpectException<NotSupportedException>(() => serviceLocator.ResolveType(typeof(DependencyInjectionTestClass))); }
public void ResolvesSameInstanceFromBothContainers() { var unityContainer = new UnityContainer(); var serviceLocator = new ServiceLocator(); serviceLocator.AutomaticallyKeepContainersSynchronized = true; serviceLocator.RegisterExternalContainer(unityContainer); serviceLocator.RegisterTypeIfNotYetRegistered<IMessageService, MessageService>(); var ns1 = unityContainer.Resolve<IMessageService>(); var ns2 = serviceLocator.ResolveType<IMessageService>(); Assert.AreEqual(ns1, ns2); }
public void ResoleType_Generic_TransientLifestyle() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterType<ITestInterface, TestClass1>(registrationType: RegistrationType.Transient); Assert.IsTrue(serviceLocator.IsTypeRegistered<ITestInterface>()); var firstInstance = serviceLocator.ResolveType<ITestInterface>(); Assert.IsInstanceOfType(firstInstance, typeof(TestClass1)); var secondInstance = serviceLocator.ResolveType<ITestInterface>(); Assert.IsInstanceOfType(secondInstance, typeof(TestClass1)); Assert.AreNotSame(firstInstance, secondInstance); }
public void TheOpenedActionIsCalledWhenViewManagerHaveRegisteredAViewForTheViewModel() { var serviceLocator = new ServiceLocator(); var fooViewModel = new FooViewModel(serviceLocator); var dispatcherServiceMock = new Mock<IDispatcherService>(); dispatcherServiceMock.Setup(service => service.Invoke(It.IsAny<Action>())).Callback((Action action) => action.Invoke()); var visualizerServiceMock = new Mock<IUIVisualizerService>(); visualizerServiceMock.Setup(service => service.Show(It.Is<FooViewModel>(model => ReferenceEquals(model, fooViewModel)), null)).Returns(true); var viewManagerMock = new Mock<IViewManager>(); viewManagerMock.Setup(manager => manager.GetViewsOfViewModel(fooViewModel)).Returns(new IView[] { new FooViewModelView(fooViewModel) }); serviceLocator.RegisterInstance<IDispatcherService>(dispatcherServiceMock.Object); serviceLocator.RegisterInstance<IUIVisualizerService>(visualizerServiceMock.Object); serviceLocator.RegisterInstance<IViewManager>(viewManagerMock.Object); serviceLocator.ResolveType<IUIVisualizerService>().Show(fooViewModel, () => { visualizerServiceMock.Verify(service => service.Show(It.Is<FooViewModel>(model => ReferenceEquals(model, fooViewModel)), null), Times.Once()); viewManagerMock.Verify(manager => manager.GetViewsOfViewModel(fooViewModel), Times.AtLeastOnce()); this.EnqueueTestComplete(); }); }
public void ResoleType_Generic_SingletonLifestyle() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterType<ITestInterface, TestClass1>(); Assert.IsTrue(serviceLocator.IsTypeRegistered<ITestInterface>()); var firstInstance = serviceLocator.ResolveType<ITestInterface>(); Assert.IsInstanceOfType(firstInstance, typeof(TestClass1)); var secondInstance = serviceLocator.ResolveType<ITestInterface>(); Assert.IsInstanceOfType(secondInstance, typeof(TestClass1)); Assert.AreSame(firstInstance, secondInstance); }
public void ResolvesTypeUsingDependencyInjectionUsesConstructorWithMostParametersFirst() { var serviceLocator = new ServiceLocator(); var typeFactory = serviceLocator.ResolveType<ITypeFactory>(); var iniEntry = new IniEntry { Group = "group", Key = "key", Value = "value" }; serviceLocator.RegisterInstance(iniEntry); serviceLocator.RegisterInstance(42); serviceLocator.RegisterInstance("hi there"); var instance = typeFactory.CreateInstance<DependencyInjectionTestClass>(); Assert.IsFalse(instance.UsedDefaultConstructor); Assert.AreEqual(iniEntry, instance.IniEntry); Assert.AreEqual(42, instance.IntValue); Assert.AreEqual("hi there", instance.StringValue); }
public void ResolveType_Generic() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterType<ITestInterface, TestClass1>(); Assert.IsTrue(serviceLocator.IsTypeRegistered<ITestInterface>()); Assert.IsInstanceOfType(serviceLocator.ResolveType<ITestInterface>(), typeof(TestClass1)); }
public void ThrowsCircularDependencyExceptionForInvalidTypeRequestPath() { var serviceLocator = new ServiceLocator(); var typeFactory = serviceLocator.ResolveType<ITypeFactory>(); serviceLocator.RegisterType<X>(); serviceLocator.RegisterType<Y>(); serviceLocator.RegisterType<Z>(); var ex = ExceptionTester.CallMethodAndExpectException<CircularDependencyException>(() => typeFactory.CreateInstance<X>()); Assert.AreEqual(4, ex.TypePath.AllTypes.Length); Assert.AreEqual(typeof(X), ex.TypePath.FirstType.Type); Assert.AreEqual(typeof(X), ex.TypePath.LastType.Type); }
public void ResolveType_InterfaceTypeNull() { var serviceLocator = new ServiceLocator(); ExceptionTester.CallMethodAndExpectException<ArgumentNullException>(() => serviceLocator.ResolveType(null)); }
public void ResolvesTypeUsingDependencyInjectionFallBackToFirstConstructor() { var serviceLocator = new ServiceLocator(); var typeFactory = serviceLocator.ResolveType<ITypeFactory>(); var iniEntry = new IniEntry { Group = "group", Key = "key", Value = "value" }; serviceLocator.RegisterInstance(iniEntry); var instance = typeFactory.CreateInstance<DependencyInjectionTestClass>(); Assert.IsFalse(instance.UsedDefaultConstructor); Assert.AreEqual(iniEntry, instance.IniEntry); Assert.AreEqual(0, instance.IntValue); Assert.AreEqual(null, instance.StringValue); }
public void ResolveType_UnregisteredType() { var serviceLocator = new ServiceLocator(); Assert.IsFalse(serviceLocator.IsTypeRegistered<ITestInterface>()); ExceptionTester.CallMethodAndExpectException<NotSupportedException>(() => serviceLocator.ResolveType(typeof(ITestInterface))); }