public void Prepare() { var map = new DependencyMap(); map.AddSingletonService <ISingleton, Singleton>(); map.AddService <ITransient, Transient>(); map.AddService <ICombined, Combined>(); this.container = map.CreateContainer(); }
private static void RegisterComplex(DependencyMap map) { map.AddSingletonService<IFirstService, FirstService>(); map.AddSingletonService<ISecondService, SecondService>(); map.AddSingletonService<IThirdService, ThirdService>(); map.AddService<ISubObjectOne, SubObjectOne>(); map.AddService<ISubObjectTwo, SubObjectTwo>(); map.AddService<ISubObjectThree, SubObjectThree>(); map.AddService<IComplex, Complex>(); }
private static void RegisterComplex(DependencyMap map) { map.AddSingletonService <IFirstService, FirstService>(); map.AddSingletonService <ISecondService, SecondService>(); map.AddSingletonService <IThirdService, ThirdService>(); map.AddService <ISubObjectOne, SubObjectOne>(); map.AddService <ISubObjectTwo, SubObjectTwo>(); map.AddService <ISubObjectThree, SubObjectThree>(); map.AddService <IComplex, Complex>(); }
public override void Prepare() { var map = new DependencyMap(); map.AddSingletonService<ISingleton, Singleton>(); map.AddService<ITransient, Transient>(); map.AddService<ICombined, Combined>(); this.container = map.CreateContainer(); }
private static void RegisterStandard(DependencyMap map) { map.AddSingletonService<ISingleton1, Singleton1>(); map.AddSingletonService<ISingleton2, Singleton2>(); map.AddSingletonService<ISingleton3, Singleton3>(); map.AddService<ITransient1, Transient1>(); map.AddService<ITransient2, Transient2>(); map.AddService<ITransient3, Transient3>(); map.AddService<ICombined1, Combined1>(); map.AddService<ICombined2, Combined2>(); map.AddService<ICombined3, Combined3>(); }
private static void RegisterDummies(DependencyMap map) { map.AddService <IDummyOne, DummyOne>(); map.AddService <IDummyTwo, DummyTwo>(); map.AddService <IDummyThree, DummyThree>(); map.AddService <IDummyFour, DummyFour>(); map.AddService <IDummyFive, DummyFive>(); map.AddService <IDummySix, DummySix>(); map.AddService <IDummySeven, DummySeven>(); map.AddService <IDummyEight, DummyEight>(); map.AddService <IDummyNine, DummyNine>(); map.AddService <IDummyTen, DummyTen>(); }
private static void RegisterDummies(DependencyMap map) { map.AddService<IDummyOne, DummyOne>(); map.AddService<IDummyTwo, DummyTwo>(); map.AddService<IDummyThree, DummyThree>(); map.AddService<IDummyFour, DummyFour>(); map.AddService<IDummyFive, DummyFive>(); map.AddService<IDummySix, DummySix>(); map.AddService<IDummySeven, DummySeven>(); map.AddService<IDummyEight, DummyEight>(); map.AddService<IDummyNine, DummyNine>(); map.AddService<IDummyTen, DummyTen>(); }
public void ShouldUseFirstNamedServiceInstanceIfNoDefaultServiceIsAvailable() { var map = new DependencyMap(); map.AddService <Garage, Garage>(); map.AddService <IVehicle, Truck>("Truck"); var container = map.CreateContainer(); var garage = container.GetInstance <Garage>(); Assert.IsNotNull(garage.Vehicle); Assert.IsInstanceOfType(typeof(Truck), garage.Vehicle); }
public Hiro() { var map = new DependencyMap(); map.AddSingletonService<Game, Game>(); map.AddService<Player, Player>(); map.AddService<Gun, Gun>(); map.AddService<Bullet, Bullet>(); Func<IMicroContainer, Bullet> createBullet = c => c.GetInstance<Bullet>(); Func<IMicroContainer, Func<Bullet>> createBulletFunctor = c => () => createBullet(c); map.AddService(createBulletFunctor); container = map.CreateContainer(); }
public void ShouldBeAbleToInstantiateNamedGenericType() { var map = new DependencyMap(); map.AddService("List", typeof(IEnumerable<>), typeof(List<>)); map.AddService("Queue", typeof(IEnumerable<>), typeof(Queue<>)); var container = map.CreateContainer(); var list = container.GetInstance<IEnumerable<int>>("List"); Assert.IsNotNull(list); var queue = container.GetInstance<IEnumerable<int>>("Queue"); Assert.IsNotNull(queue); Assert.IsFalse(queue.GetType() != list.GetType()); }
public void ShouldInjectPropertyIfDependencyMapHasAPropertyInjectorAssignedToTheInjectorProperty() { var map = new DependencyMap(); map.Injector = new PropertyInjector(); map.AddService<IVehicle, Vehicle>(); map.AddService<IPerson, Person>(); var container = map.CreateContainer(); var result = (IVehicle)container.GetInstance(typeof(IVehicle), null); Assert.IsNotNull(result); Assert.IsNotNull(result.Driver); Assert.IsTrue(result.Driver is Person); }
public void ShouldBeAbleToCompileContainerUsingATypeWithMultipleConstructors() { var map = new DependencyMap(); map.AddService(typeof(IVehicle), typeof(Vehicle)); map.AddService(typeof(IPerson), typeof(Person)); var container = Compile(map); var result = container.GetInstance(typeof(IVehicle), null); var vehicle = (IVehicle)result; Assert.IsNotNull(vehicle); Assert.IsNotNull(vehicle.Driver); }
/// <summary> /// Adds a named service to the dependency map. /// </summary> /// <remarks>This service will be created once per web session.</remarks> /// <param name="map">The target dependency map.</param> /// <param name="serviceName">The service name.</param> /// <param name="serviceType">The service type.</param> /// <param name="implementingType">The implementing type.</param> public static void AddPerSessionService(this DependencyMap map, string serviceName, Type serviceType, Type implementingType) { // Add the SessionCache by default if (!map.Contains(typeof(ICache))) { map.AddService <ICache, SessionCache>(); } // The cached instantiation class will use the cache in the container // to cache service instances var dependency = new Dependency(serviceType, serviceName); var implementation = new CachedInstantiation(new TransientType(implementingType, map, new ConstructorResolver())); map.AddService(dependency, implementation); }
public void ShouldUseConstructorParameterNameToInjectNamedServiceInstanceIfTheNamedServiceExists() { var map = new DependencyMap(); map.AddService <IVehicle, Vehicle>("Vehicle"); map.AddService <IVehicle, Truck>("Truck"); map.AddService <Garage, Garage>(); var container = map.CreateContainer(); var garage = container.GetInstance <Garage>(); Assert.IsNotNull(garage.Vehicle); Assert.IsInstanceOfType(typeof(Vehicle), garage.Vehicle); }
public void Load(DependencyMap map) { _invoked = true; // Add a sample implementation map.AddService<IList<int>, List<int>>(); }
public void ShouldBeAbleToAddDeferredServiceToContainer() { var map = new DependencyMap(); map.AddDeferredService(typeof(IPerson)); map.Injector = new PropertyInjector(); map.AddService(typeof(Truck), typeof(Truck)); var mockPerson = new Mock <IPerson>(); var container = map.CreateContainer(); container.AddService(mockPerson.Object); // The container must instantiate the mock person type var person = container.GetInstance <IPerson>(); Assert.AreSame(mockPerson.Object, person); Assert.IsNotNull(person); // Make sure the person instance is injected into // the target property var truck = container.GetInstance <Truck>(); Assert.IsNotNull(truck); Assert.AreSame(truck.Driver, mockPerson.Object); }
public void ShouldBeAbleToReturnAllAvailableImplementationsForADependency() { var numberOfImplementations = 5; var implementations = Enumerable.Range(0, numberOfImplementations) .Select(_ => A.Fake <IImplementation>()).ToArray(); var dependency = new Dependency(typeof(IEnumerable <string>)); var map = new DependencyMap(); for (var i = 0; i < numberOfImplementations; i++) { var implementation = implementations[i]; map.AddService(dependency, implementation); } Assert.True(map.Contains(dependency)); Assert.Contains(dependency, map.Dependencies); var results = map.GetImplementations(dependency, false).ToArray(); for (var i = 0; i < numberOfImplementations; i++) { Assert.Contains(implementations[i], results); } }
public void ShouldBeAbleToAddMultipleServices() { var numberOfDependencies = 5; var implementations = Enumerable.Range(0, numberOfDependencies) .Select(_ => A.Fake <IImplementation>()).ToArray(); var dependencies = Enumerable.Range(0, numberOfDependencies) .Select(_ => A.Fake <IDependency>()).ToArray(); var map = new DependencyMap(); for (var i = 0; i < numberOfDependencies; i++) { var dependency = dependencies[i]; var implementation = implementations[i]; map.AddService(dependency, implementation); } for (var i = 0; i < numberOfDependencies; i++) { var dependency = dependencies[i]; Assert.True(map.Contains(dependency)); Assert.Contains(dependency, map.Dependencies); } }
/// <summary> /// Loads a dependency map using the types in the given <paramref name="assemblies"/>. /// </summary> /// <param name="assemblies">The list of assemblies that will be used to construct the dependency map.</param> /// <returns>A dependency map.</returns> public DependencyMap LoadFrom(IEnumerable <Assembly> assemblies) { var map = new DependencyMap(_constructorResolver) { Injector = new PropertyInjector() }; var defaultImplementations = new Dictionary <System.Type, IImplementation>(); foreach (var assembly in assemblies) { var embeddedTypes = _typeLoader.LoadTypes(assembly); foreach (var type in embeddedTypes) { if (type.IsInterface || type.IsAbstract || type.IsGenericTypeDefinition || type.IsValueType) { continue; } RegisterNamedFactoryType(type, defaultImplementations, map); } } foreach (var serviceType in defaultImplementations.Keys) { var dependency = new Dependency(serviceType); var implementation = defaultImplementations[serviceType]; map.AddService(dependency, implementation); } RegisterServicesFrom(assemblies, map); return(map); }
public void Load(DependencyMap map) { _invoked = true; // Add a sample implementation map.AddService <IList <int>, List <int> >(); }
public Hiro() { var map = new DependencyMap(); map.AddSingletonService <Game, Game>(); map.AddService <Player, Player>(); map.AddService <Gun, Gun>(); map.AddService <Bullet, Bullet>(); Func <IMicroContainer, Bullet> createBullet = c => c.GetInstance <Bullet>(); Func <IMicroContainer, Func <Bullet> > createBulletFunctor = c => () => createBullet(c); map.AddService(createBulletFunctor); container = map.CreateContainer(); }
/// <summary> /// Registers a service with a dependency map. /// </summary> /// <param name="map">The dependency map.</param> /// <param name="service">The service that will be registered with the dependency map.</param> internal static void Register(this DependencyMap map, IServiceInfo service) { var serviceName = service.ServiceName; var serviceType = service.ServiceType; var implementingType = service.ImplementingType; map.AddService(serviceName, serviceType, implementingType); }
public void ShouldBeAbleToRegisterAnonymousServicesWithDependencyMapUsingGenerics() { var dependencyMap = new DependencyMap(); dependencyMap.AddService<IVehicle, Vehicle>(); Assert.IsTrue(dependencyMap.Contains(new Dependency(typeof(IVehicle)))); Assert.IsTrue(dependencyMap.Contains(typeof(IVehicle))); }
public void ShouldInjectPropertyIfDependencyMapHasAPropertyInjectorAssignedToTheInjectorProperty() { var map = new DependencyMap(); map.Injector = new PropertyInjector(); map.AddService <IVehicle, Vehicle>(); map.AddService <IPerson, Person>(); var container = map.CreateContainer(); var result = (IVehicle)container.GetInstance(typeof(IVehicle), null); Assert.IsNotNull(result); Assert.IsNotNull(result.Driver); Assert.IsTrue(result.Driver is Person); }
public void ShouldInjectDefaultServiceImplementationIntoTargetProperty() { var map = new DependencyMap(); var dependency = new Dependency(typeof(IVehicle)); var injector = new PropertyInjectionCall(new TransientType(typeof(Vehicle), map, new ConstructorResolver())); map.AddService(dependency, injector); map.AddService(typeof(IPerson), typeof(Person)); var container = map.CreateContainer(); var result = (IVehicle)container.GetInstance(typeof(IVehicle), null); Assert.IsNotNull(result); Assert.IsNotNull(result.Driver); Assert.IsTrue(result.Driver is Person); }
public void ShouldBeAbleToRegisterNamedServicesWithDependencyMapUsingGenerics() { var serviceName = "MyService"; var dependencyMap = new DependencyMap(); dependencyMap.AddService <IVehicle, Vehicle>(serviceName); Assert.IsTrue(dependencyMap.Contains(typeof(IVehicle), serviceName)); }
public void ShouldBeAbleToInstantiateNamedGenericType() { var map = new DependencyMap(); map.AddService("List", typeof(IEnumerable <>), typeof(List <>)); map.AddService("Queue", typeof(IEnumerable <>), typeof(Queue <>)); var container = map.CreateContainer(); var list = container.GetInstance <IEnumerable <int> >("List"); Assert.IsNotNull(list); var queue = container.GetInstance <IEnumerable <int> >("Queue"); Assert.IsNotNull(queue); Assert.IsFalse(queue.GetType() != list.GetType()); }
public void ShouldBeAbleToRegisterAnonymousServicesWithDependencyMap() { var dependencyMap = new DependencyMap(); dependencyMap.AddService(typeof(IVehicle), typeof(Vehicle)); Assert.IsTrue(dependencyMap.Contains(new Dependency(typeof(IVehicle)))); Assert.IsTrue(dependencyMap.Contains(typeof(IVehicle))); }
public void ShouldBeAbleToInstantiateGenericTypes() { var map = new DependencyMap(); map.AddService(typeof(IList<>), typeof(List<>)); var container = map.CreateContainer(); var list = container.GetInstance<IList<int>>(); Assert.IsNotNull(list); }
public void ShouldBeAbleToUseGenericsToGetAnonymousServiceInstances() { var map = new DependencyMap(); map.AddService(typeof(IPerson), typeof(Person)); var container = map.CreateContainer(); IPerson person = container.GetInstance<IPerson>(); Assert.IsNotNull(person); }
public void ShouldBeAbleToAddItemsToDependencyMap() { var ctor = typeof(Vehicle).GetConstructor(new Type[0]); var dependency = new Dependency(typeof(IVehicle), string.Empty); var constructorImplementation = new ConstructorCall(ctor); var dependencyMap = new DependencyMap(); dependencyMap.AddService(dependency, constructorImplementation); Assert.IsTrue(dependencyMap.Contains(dependency)); }
public void ShouldCallContainerPluginOnceContainerIsInstantiated() { var map = new DependencyMap(); map.AddService <IContainerPlugin, SamplePlugin>(); var container = map.CreateContainer(); Assert.IsTrue(SamplePlugin.HasBeenCalled); }
public void ShouldBeAbleToInstantiateGenericTypes() { var map = new DependencyMap(); map.AddService(typeof(IList <>), typeof(List <>)); var container = map.CreateContainer(); var list = container.GetInstance <IList <int> >(); Assert.IsNotNull(list); }
public void ShouldHaveTwoEqualDependencyMapsIfBothMapsContainTheSameDependencies() { var firstMap = new DependencyMap(); var secondMap = new DependencyMap(); firstMap.AddService(typeof(IPerson), typeof(Person)); secondMap.AddService(typeof(IPerson), typeof(Person)); Assert.AreEqual(firstMap, secondMap); Assert.AreEqual(firstMap.GetHashCode(), secondMap.GetHashCode()); }
public void ShouldBeAbleToUseGenericsToGetAnonymousServiceInstances() { var map = new DependencyMap(); map.AddService(typeof(IPerson), typeof(Person)); var container = map.CreateContainer(); IPerson person = container.GetInstance <IPerson>(); Assert.IsNotNull(person); }
public void ShouldBeAbleToGetCurrentListOfDependencies() { var map = new DependencyMap(); for (int i = 0; i < 10; i++) { var dependency = new Mock<IDependency>(); var implementation = new Mock<IImplementation>(); map.AddService(dependency.Object, implementation.Object); Assert.IsTrue(map.Dependencies.Contains(dependency.Object)); } }
public void ShouldBeAbleToCompileContainerFromDependencyMap() { var map = new DependencyMap(); map.AddService(typeof(IPerson), typeof(Person)); var container = map.CreateContainer(); var result = container.GetInstance(typeof(IPerson), null); Assert.IsNotNull(result); Assert.IsTrue(result is Person); }
public void ShouldBeAbleToReturnAllAvailableImplementationsForADependencyExceptForTheIncompleteDependencies() { var numberOfImplementations = 5; var numberOfIncompleteImplementations = 3; IEnumerable <IImplementation> CreateImplementations(int numberOfImplementationsToCreate, bool isCompleted) { var incompleteDependencies = isCompleted ? Enumerable.Empty <IDependency>() : new[] { A.Fake <IDependency>() }; return(Enumerable.Range(0, numberOfImplementationsToCreate) .Select(_ => { var currentImplementation = A.Fake <IImplementation>(); A.CallTo(() => currentImplementation.GetMissingDependencies(A <IDependencyMap> .Ignored)) .Returns(incompleteDependencies); return currentImplementation; }).ToArray()); } var implementations = new List <IImplementation>(); implementations.AddRange(CreateImplementations(numberOfImplementations, true)); var incompleteImplementations = CreateImplementations(numberOfIncompleteImplementations, false) .ToArray(); implementations.AddRange(incompleteImplementations); var dependency = new Dependency(typeof(IEnumerable <string>)); var map = new DependencyMap(); foreach (var implementation in implementations) { map.AddService(dependency, implementation); } Assert.True(map.Contains(dependency)); Assert.Contains(dependency, map.Dependencies); var results = map.GetImplementations(dependency, false).ToArray(); for (var i = 0; i < numberOfImplementations; i++) { Assert.Contains(implementations[i], results); } foreach (var implementation in incompleteImplementations) { Assert.DoesNotContain(implementation, results); } }
public void ShouldBeAbleToGetAllInstancesOfATypeFromACompiledContainer() { var map = new DependencyMap(); map.AddService(typeof(IVehicle), typeof(Vehicle)); map.AddService("Truck", typeof(IVehicle), typeof(Truck)); var compiler = new ContainerCompiler(); var assembly = compiler.Compile("MicroContainer", "Hiro.Containers", "Hiro.CompiledContainers", map); var container = Compile(map); var instances = container.GetAllInstances(typeof(IVehicle)); Assert.IsNotNull(instances); Assert.IsTrue(instances.Count() == 2); var items = instances.ToArray(); Assert.IsTrue(items[0] is Vehicle); Assert.IsTrue(items[1] is Truck); }
public void ShouldBeAbleToCreateTheSameContainerTypeFromASingleDependencyMap() { var map = new DependencyMap(); map.AddService(typeof(IPerson), typeof(Person)); var firstContainer = map.CreateContainer(); var secondContainer = map.CreateContainer(); Assert.AreEqual(firstContainer.GetType(), secondContainer.GetType()); }
public void ShouldCallImplementationInjectorIfItExists() { var injector = new Mock <IImplementationInjector>(); var map = new DependencyMap(); map.Injector = injector.Object; injector.Expect(i => i.Inject(It.IsAny <IDependency>(), It.IsAny <IImplementation>())).Returns(new TransientType(typeof(Vehicle), map, new ConstructorResolver())); map.AddService <IVehicle, Vehicle>(); injector.VerifyAll(); }
public void ShouldCallInitializeOnTransientTypeThatImplementsIInitializeWhenCallingGetAllInstances() { var map = new DependencyMap(); map.AddService <IInitialize, SampleInitialize>(); var container = map.CreateContainer(); var result = (SampleInitialize)container.GetAllInstances(typeof(IInitialize)).Cast <IInitialize>().First(); Assert.AreSame(container, result.Container); Assert.IsTrue(result.NumberOfTimesInitialized == 1); }
public void ShouldBeAbleToGetAllEnumerableInstancesOfAGivenService() { var map = new DependencyMap(); map.AddService("Baz1", typeof(IBaz<int>), typeof(Baz1)); map.AddService("Baz2", typeof(IBaz<int>), typeof(Baz2)); map.AddService("Baz3", typeof(IBaz<int>), typeof(Baz3)); map.AddService(typeof(IFizz), typeof(SampleClassWithEnumerableBazDependency)); // Make the IEnumerable<IBazz<int>> service explictly resolvable map.AddAsEnumerableService(typeof(IBaz<int>)); var container = map.CreateContainer(); var fizz = container.GetInstance<IFizz>(); Assert.IsNotNull(fizz); Assert.AreEqual(3, fizz.Services.Count()); var services = fizz.Services.ToArray(); Assert.IsInstanceOfType(typeof(Baz1), services[0]); Assert.IsInstanceOfType(typeof(Baz2), services[1]); Assert.IsInstanceOfType(typeof(Baz3), services[2]); }
public void ShouldBeAbleToAddTypedFunctorToDependencyMap() { var expectedInstance = new Foo(); Func<IMicroContainer, IFoo> functor = c => expectedInstance; var map = new DependencyMap(); map.AddService(functor); var container = map.CreateContainer(); var foo = container.GetInstance<IFoo>(); Assert.AreSame(expectedInstance, foo); }
public void ShouldBeAbleToCombineDependencyMaps() { var firstMap = new DependencyMap(); var secondMap = new DependencyMap(); firstMap.AddService(typeof(IPerson), typeof(Person)); secondMap.AddService(typeof(IVehicle), typeof(Vehicle)); DependencyMap combinedMap = firstMap + secondMap; var container = combinedMap.CreateContainer(); Assert.IsNotNull(container.GetInstance<IVehicle>()); Assert.IsNotNull(container.GetInstance<IPerson>()); }
public void ShouldBeAbleToAddNamedUntypedFunctorToDependencyMap() { var expectedInstance = new Foo(); Func<IMicroContainer, object> functor = c => expectedInstance; var serviceType = typeof(IFoo); var map = new DependencyMap(); map.AddService("myFoo", serviceType, functor); var container = map.CreateContainer(); var foo = container.GetInstance<IFoo>("myFoo"); Assert.IsNotNull(foo); Assert.AreSame(expectedInstance, foo); }
public void ShouldBeAbleToInjectGenericConstructor() { var map = new DependencyMap(); map.AddService<UnitOfWorkScopeBase<UserUnitOfWork>, SimpleUnitOfWorkScope<UserUnitOfWork>>(); map.AddSingletonService<LightSpeedContext<UserUnitOfWork>, LightSpeedContext<UserUnitOfWork>>(); var container = map.CreateContainer(); var service = container.GetInstance<UnitOfWorkScopeBase<UserUnitOfWork>>(); Assert.IsNotNull(service); }
public void ShouldCallCacheOnCachedServiceType() { var map = new DependencyMap(); var dependency = new Dependency(typeof(IFoo)); var implementation = new TransientType(typeof(Foo), map, new ConstructorResolver()); var cachedImplementation = new CachedInstantiation(implementation); map.AddSingletonService<ICache, MockCache>(); map.AddService(dependency, cachedImplementation); // Compile the container var container = map.CreateContainer(); // Grab the service instance var firstResult = container.GetInstance<IFoo>(); var secondResult = container.GetInstance<IFoo>(); Assert.IsNotNull(firstResult); Assert.AreSame(firstResult, secondResult); }
static HiroUseCase() { var map = new DependencyMap(); map.AddService(typeof(IWebService), typeof(WebService)); map.AddService(typeof(IAuthenticator), typeof(Authenticator)); map.AddService(typeof(IStockQuote), typeof(StockQuote)); map.AddService(typeof(IDatabase), typeof(Database)); map.AddService(typeof(IErrorHandler), typeof(ErrorHandler)); map.AddService(typeof(ILogger), typeof(Logger)); IContainerCompiler compiler = new ContainerCompiler(); var assembly = compiler.Compile(map); var loadedAssembly = assembly.ToAssembly(); var containerType = loadedAssembly.GetTypes()[0]; container = (IMicroContainer)Activator.CreateInstance(containerType); }
public void ShouldBeAbleToAddDeferredServiceToContainer() { var map = new DependencyMap(); map.AddDeferredService(typeof(IPerson)); map.Injector = new PropertyInjector(); map.AddService(typeof(Truck), typeof(Truck)); var mockPerson = new Mock<IPerson>(); var container = map.CreateContainer(); container.AddService(mockPerson.Object); // The container must instantiate the mock person type var person = container.GetInstance<IPerson>(); Assert.AreSame(mockPerson.Object, person); Assert.IsNotNull(person); // Make sure the person instance is injected into // the target property var truck = container.GetInstance<Truck>(); Assert.IsNotNull(truck); Assert.AreSame(truck.Driver, mockPerson.Object); }
public void ShouldReturnImplementationsFromDependencyMapFromImplementationsThatHaveNoMissingDependencies() { var map = new DependencyMap(); var dependency = new Dependency(typeof(IVehicle), string.Empty); var implementation = new Mock<IImplementation>(); implementation.Expect(impl => impl.GetMissingDependencies(map)).Returns(new IDependency[0]); bool addIncompleteImplementations = false; map.AddService(dependency, implementation.Object); var results = map.GetImplementations(dependency, addIncompleteImplementations); Assert.IsTrue(results.Count() > 0); Assert.IsTrue(results.Contains(implementation.Object)); implementation.VerifyAll(); }
public void ShouldBeAbleToRegisterNamedServicesWithDependencyMap() { var serviceName = "MyService"; var dependencyMap = new DependencyMap(); dependencyMap.AddService<IVehicle, Vehicle>(serviceName); Assert.IsTrue(dependencyMap.Contains(typeof(IVehicle), serviceName)); }
public void ShouldCallImplementationInjectorIfItExists() { var injector = new Mock<IImplementationInjector>(); var map = new DependencyMap(); map.Injector = injector.Object; injector.Expect(i => i.Inject(It.IsAny<IDependency>(), It.IsAny<IImplementation>())).Returns(new TransientType(typeof(Vehicle), map, new ConstructorResolver())); map.AddService<IVehicle, Vehicle>(); injector.VerifyAll(); }
private static void RegisterPropertyInjection(DependencyMap map) { map.AddSingletonService<IServiceA, ServiceA>(); map.AddSingletonService<IServiceB, ServiceB>(); map.AddSingletonService<IServiceC, ServiceC>(); map.AddService(new Func<IMicroContainer, ISubObjectA>( microContainer => new SubObjectA { ServiceA = microContainer.GetInstance<IServiceA>() })); map.AddService(new Func<IMicroContainer, ISubObjectB>( microContainer => new SubObjectB { ServiceB = microContainer.GetInstance<IServiceB>() })); map.AddService(new Func<IMicroContainer, ISubObjectC>( microContainer => new SubObjectC { ServiceC = microContainer.GetInstance<IServiceC>() })); // HACK: We must wrap the delegate explicitly in a Func<T, TResult> or else resolving will fail. map.AddService(new Func<IMicroContainer, IComplexPropertyObject1>( microContainer => new ComplexPropertyObject1 { ServiceA = microContainer.GetInstance<IServiceA>(), ServiceB = microContainer.GetInstance<IServiceB>(), ServiceC = microContainer.GetInstance<IServiceC>(), SubObjectA = microContainer.GetInstance<ISubObjectA>(), SubObjectB = microContainer.GetInstance<ISubObjectB>(), SubObjectC = microContainer.GetInstance<ISubObjectC>() })); map.AddService(new Func<IMicroContainer, IComplexPropertyObject2>( microContainer => new ComplexPropertyObject2 { ServiceA = microContainer.GetInstance<IServiceA>(), ServiceB = microContainer.GetInstance<IServiceB>(), ServiceC = microContainer.GetInstance<IServiceC>(), SubObjectA = microContainer.GetInstance<ISubObjectA>(), SubObjectB = microContainer.GetInstance<ISubObjectB>(), SubObjectC = microContainer.GetInstance<ISubObjectC>() })); map.AddService(new Func<IMicroContainer, IComplexPropertyObject3>( microContainer => new ComplexPropertyObject3 { ServiceA = microContainer.GetInstance<IServiceA>(), ServiceB = microContainer.GetInstance<IServiceB>(), ServiceC = microContainer.GetInstance<IServiceC>(), SubObjectA = microContainer.GetInstance<ISubObjectA>(), SubObjectB = microContainer.GetInstance<ISubObjectB>(), SubObjectC = microContainer.GetInstance<ISubObjectC>() })); }
private static void RegisterStandard(DependencyMap map) { map.AddSingletonService<ISingleton, Singleton>(); map.AddService<ITransient, Transient>(); map.AddService<ICombined, Combined>(); }
public void ShouldBeAbleToResolvePlayerInstanceWithoutEncounteringACLRLimitationError() { var map = new DependencyMap(); map.AddSingletonService<Game, Game>(); map.AddService<Player, Player>(); map.AddService<Gun, Gun>(); map.AddService<Bullet, Bullet>(); Func<IMicroContainer, Bullet> createBullet = c => c.GetInstance<Bullet>(); Func<IMicroContainer, Func<Bullet>> createBulletFunctor = c => () => createBullet(c); map.AddService(createBulletFunctor); var container = map.CreateContainer(); Assert.IsNotNull(container); var player = container.GetInstance<Player>(); Assert.IsNotNull(player); player.Shoot(); }
public void should_create_either_both_empty_or_both_equivalent_and_not_null() { var map1 = new DependencyMapLoader().LoadFrom(typeof(ISomeService).Assembly); var container1 = map1.CreateContainer(); var service1 = container1.GetInstance<ISomeService>(); var map2 = new DependencyMap(); map2.AddService<ISomeService,SomeService>(); var container2 = map2.CreateContainer(); var service2 = container2.GetInstance<ISomeService>(); Assert.IsFalse(service2==null||service1==null,"At least one service is null 1:{0} 2:{1}",service1,service2); Assert.AreEqual(service1.GetType(),service2.GetType(),"types are not the same"); }