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)); }
/// <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 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 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); }
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 ShouldBeEqualIfServiceNameAndServiceTypeAreTheSame() { var first = new Dependency(typeof(IPerson), string.Empty); var second = new Dependency(typeof(IPerson), string.Empty); Assert.AreEqual(first, second); Assert.AreEqual(first.GetHashCode(), second.GetHashCode()); }
/// <summary> /// Registers a type as a factory type if it implements the <see cref="IFactory{T}"/> interface. /// </summary> /// <param name="type">The target type</param> /// <param name="defaultImplementations">The list of default implementations per service type.</param> /// <param name="map">The dependency map.</param> private void RegisterNamedFactoryType(Type type, IDictionary<Type, IImplementation> defaultImplementations, IDependencyMap map) { var factoryTypeDefinition = typeof(IFactory<>); var interfaces = type.GetInterfaces(); foreach (var interfaceType in interfaces) { if (!interfaceType.IsGenericType) continue; var definitionType = interfaceType.GetGenericTypeDefinition(); if (definitionType != factoryTypeDefinition) continue; var genericArguments = interfaceType.GetGenericArguments(); var actualServiceType = genericArguments[0]; var serviceName = type.Name; var nameLength = serviceName.Length; var hasSpecialName = serviceName.EndsWith("Factory") && nameLength > 7; serviceName = hasSpecialName ? serviceName.Substring(0, nameLength - 7) : serviceName; var implementation = new FactoryCall(actualServiceType, type.Name); // Register the default implementation if necessary if (!defaultImplementations.ContainsKey(actualServiceType)) defaultImplementations[actualServiceType] = implementation; var dependency = new Dependency(actualServiceType, serviceName); map.AddService(dependency, implementation); } }
/// <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<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; }