public RegisterType ( |
||
serviceType | The type of the service. | |
createServiceFunc | object>.Func | The create service function. |
tag | object | The tag to register the service with. The default value is |
registrationType | RegistrationType | The registration type. The default value is |
registerIfAlreadyRegistered | bool | If set to |
return | void |
public override void Prepare() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterType<ISingleton, Singleton>(RegistrationType.Singleton); serviceLocator.RegisterType<ITransient, Transient>(RegistrationType.Transient); serviceLocator.RegisterType<ICombined, Combined>(RegistrationType.Transient); container = serviceLocator; }
public void ResolvesInstancesOfTypeRegisteredWithSingletonParameterToFalseFromNinjectContainer() { var serviceLocator = new ServiceLocator(); var standardKernel = new StandardKernel(); serviceLocator.RegisterExternalContainer(standardKernel); serviceLocator.RegisterType<ITestInterface, TestClass1>(registrationType: RegistrationType.Transient); Assert.AreNotSame(standardKernel.Get<ITestInterface>(), standardKernel.Get<ITestInterface>()); }
public void ReturnsTrueForRegisteredType() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterType<IMessageService, MessageService>(); var dependencyResolver = serviceLocator.ResolveType<IDependencyResolver>(); Assert.IsTrue(dependencyResolver.CanResolve(typeof(IMessageService))); }
public void ResolvesInstancesOfTypeRegisteredWithSingletonParameterToTrueFromWindsorContainer() { var serviceLocator = new ServiceLocator(); var windsorContainer = new WindsorContainer(); serviceLocator.RegisterExternalContainer(windsorContainer); serviceLocator.RegisterType<ITestInterface, TestClass1>(); Assert.AreSame(windsorContainer.Resolve<ITestInterface>(), windsorContainer.Resolve<ITestInterface>()); }
public void GetAllInstanceJustReturnsCollectionOfWithOnylOneResolvedInstanceIfTheTypeIsRegistered() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterType<IFooInterface, FooNonAbstractClass>(); var serviceLocatorAdapter = new ServiceLocatorAdapter(serviceLocator); IFooInterface[] list = serviceLocatorAdapter.GetAllInstances<IFooInterface>().ToArray(); Assert.AreEqual(1, list.Length); }
public void ResolvesInstancesOfTypeRegisteredWithSingletonParameterToFalseFromUnityContainer() { var serviceLocator = new ServiceLocator(); var unityContainer = new UnityContainer(); serviceLocator.RegisterExternalContainer(unityContainer); serviceLocator.RegisterType<ITestInterface, TestClass1>(registrationType: RegistrationType.Transient); Assert.AreNotSame(unityContainer.Resolve<ITestInterface>(), unityContainer.Resolve<ITestInterface>()); }
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 InvokesTypeRegisteredEvent() { var serviceLocator = new ServiceLocator(); TypeRegisteredEventArgs eventArgs = null; serviceLocator.TypeRegistered += (sender, args) => { eventArgs = args; }; serviceLocator.RegisterType<ITestInterface, TestClass2>(registrationType: RegistrationType.Transient); Assert.IsNotNull(eventArgs); Assert.AreEqual(typeof(ITestInterface), eventArgs.ServiceType); Assert.AreEqual(typeof(TestClass2), eventArgs.ServiceImplementationType); Assert.AreEqual(RegistrationType.Transient, eventArgs.RegistrationType); }
public void ThrowsNotSupportedExceptionWhenAtLeastOneTypeIsNotRegistered() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterType<object>(); serviceLocator.RegisterType<ITestInterface1, TestClass1>(); ExceptionTester.CallMethodAndExpectException<NotSupportedException>(() => serviceLocator.ResolveAllTypes(typeof(object), typeof(ITestInterface1), typeof(ITestInterface2))); }
public void ResolvesTypeUsingDependencyInjectionUsesConstructorWithMostParametersFirst() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterType<DependencyInjectionTestClass, DependencyInjectionTestClass>(); var iniEntry = new IniEntry { Group = "group", Key = "key", Value = "value" }; serviceLocator.RegisterInstance(iniEntry); serviceLocator.RegisterInstance(42); serviceLocator.RegisterInstance("hi there"); var instance = serviceLocator.ResolveType<DependencyInjectionTestClass>(); Assert.IsFalse(instance.UsedDefaultConstructor); Assert.AreEqual(iniEntry, instance.IniEntry); Assert.AreEqual(42, instance.IntValue); Assert.AreEqual("hi there", instance.StringValue); }
public void ResolveType_RegisteredAsTypeInServiceLocator() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterType<ITestInterface, TestClass1>(); var instance = serviceLocator.ResolveType<ITestInterface>(); Assert.IsInstanceOfType(instance, typeof(TestClass1)); }
public void TheIsTypeRegisteredAsSingleton_NonSingleton() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterType<ITestInterface, TestClass1>(registrationType: RegistrationType.Transient); Assert.IsFalse(serviceLocator.IsTypeRegisteredAsSingleton(typeof(ITestInterface))); }
public void TheIsTypeRegisteredAsSingleton_Generic() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterType<ITestInterface, TestClass1>(); Assert.IsTrue(serviceLocator.IsTypeRegisteredAsSingleton<ITestInterface>()); }
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 AllowsTheSameInterfaceDefinedTwiceWithDifferentTags() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterType(typeof(ITestInterface), typeof(TestClass1), "1"); serviceLocator.RegisterType(typeof(ITestInterface), typeof(TestClass1), "2"); Assert.IsFalse(serviceLocator.IsTypeRegistered(typeof(ITestInterface))); Assert.IsTrue(serviceLocator.IsTypeRegistered(typeof(ITestInterface), "1")); Assert.IsTrue(serviceLocator.IsTypeRegistered(typeof(ITestInterface), "2")); }
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 ReturnsAllTypesWhenAllAreRegistered() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterInstance(new object()); serviceLocator.RegisterType<ITestInterface1, TestClass1>(); serviceLocator.RegisterType<ITestInterface2, TestClass2>(); var resolvedTypes = serviceLocator.ResolveAllTypes(typeof(object), typeof(ITestInterface1), typeof(ITestInterface2)).ToArray(); Assert.AreEqual(3, resolvedTypes.Length); Assert.AreEqual(typeof(object), resolvedTypes[0].GetType()); Assert.AreEqual(typeof(TestClass1), resolvedTypes[1].GetType()); Assert.AreEqual(typeof(TestClass2), resolvedTypes[2].GetType()); }
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 ResolveType_Generic() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterType<ITestInterface, TestClass1>(); Assert.IsTrue(serviceLocator.IsTypeRegistered<ITestInterface>()); Assert.IsInstanceOfType(serviceLocator.ResolveType<ITestInterface>(), typeof(TestClass1)); }
public void IsTypeRegistered_RegisteredAsTypeInServiceLocator() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterType<ITestInterface, TestClass1>(); Assert.IsTrue(serviceLocator.IsTypeRegistered(typeof(ITestInterface))); }
public void ResolvesTypeUsingDependencyInjectionFallBackToDefaultConstructor() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterType<DependencyInjectionTestClass, DependencyInjectionTestClass>(); var instance = serviceLocator.ResolveType<DependencyInjectionTestClass>(); Assert.IsTrue(instance.UsedDefaultConstructor); }
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 ResolvesTypeUsingDependencyInjectionFallBackToSecondConstructor() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterType<DependencyInjectionTestClass, DependencyInjectionTestClass>(); var iniEntry = new IniEntry { Group = "group", Key = "key", Value = "value" }; serviceLocator.RegisterInstance(iniEntry); serviceLocator.RegisterInstance(42); var instance = serviceLocator.ResolveType<DependencyInjectionTestClass>(); Assert.IsFalse(instance.UsedDefaultConstructor); Assert.AreEqual(iniEntry, instance.IniEntry); Assert.AreEqual(42, instance.IntValue); Assert.AreEqual(null, instance.StringValue); }
public void ReturnsFalseWhenAtLeastOneTypeIsNotRegistered() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterType<object>(); serviceLocator.RegisterType<ITestInterface1, TestClass1>(); Assert.IsFalse(serviceLocator.AreAllTypesRegistered(typeof(object), typeof(ITestInterface1), typeof(ITestInterface2))); }
public void RegisterType_ImplementingTypeNull() { var serviceLocator = new ServiceLocator(); ExceptionTester.CallMethodAndExpectException<ArgumentNullException>(() => serviceLocator.RegisterType(typeof(ITestInterface), null, null, RegistrationType.Singleton, true, null)); }
public void ReturnsTrueWhenAllTypesAreRegistered() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterType<object>(); serviceLocator.RegisterType<ITestInterface1, TestClass1>(); serviceLocator.RegisterType<ITestInterface2, TestClass2>(); Assert.IsTrue(serviceLocator.AreAllTypesRegistered(typeof(object), typeof(ITestInterface1), typeof(ITestInterface2))); }
public void ExportsBothInstancesAndTypes() { var serviceLocator = new ServiceLocator(); serviceLocator.AutomaticallyKeepContainersSynchronized = false; var ninjectContainer = new StandardKernel(); serviceLocator.RegisterExternalContainer(ninjectContainer); serviceLocator.RegisterInstance<ITestInterface>(new TestClass1()); serviceLocator.RegisterType<INotifyPropertyChanged, TestClass1>(); serviceLocator.RegisterExternalContainer(ninjectContainer); Assert.IsFalse(ninjectContainer.GetBindings(typeof(INotifyPropertyChanged)).Any()); Assert.IsFalse(ninjectContainer.GetBindings(typeof(ITestInterface)).Any()); Assert.IsTrue(serviceLocator.IsTypeRegistered<ITestInterface>()); serviceLocator.ExportToExternalContainers(); Assert.IsTrue(ninjectContainer.GetBindings(typeof(INotifyPropertyChanged)).Any()); Assert.IsTrue(ninjectContainer.GetBindings(typeof(ITestInterface)).Any()); Assert.IsTrue(serviceLocator.IsTypeRegistered<ITestInterface>()); }
public void RegisterType_Valid() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterType<ITestInterface, TestClass1>(); Assert.IsTrue(serviceLocator.IsTypeRegistered<ITestInterface>()); }
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 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)); }