/// <summary>
/// Resolve a dependency from the container.
/// </summary>
/// <typeparam name="T">The dependency type.</typeparam>
/// <returns>The located dependency.</returns>
public T Resolve <T>()
{
Type type = typeof(T);
RegisteredDependency dependency = ResolveDependency(type);
return((T)Instantiate(dependency));
}
public void DelegateFactory_CreatesInstances()
{
var registeredDependency = new RegisteredDependency {
Value = "registered"
};
var unregisteredDependency = new UnregisteredDependency {
Value = "unregistered"
};
var expectedInstance = new Foo(registeredDependency, unregisteredDependency);
var providerMock = new Mock <IServiceProvider>();
var provider = providerMock.Object;
var timesCalled = 0;
IFoo FactoryFunc(IServiceProvider prov, UnregisteredDependency dep)
{
timesCalled++;
Assert.Same(provider, prov);
Assert.Same(unregisteredDependency, dep);
return(expectedInstance);
}
var factory = new DelegateFactory <IFoo, UnregisteredDependency>(provider, FactoryFunc);
var instance = factory.CreateService(unregisteredDependency);
Assert.Same(expectedInstance, instance);
Assert.Equal(1, timesCalled);
providerMock.VerifyNoOtherCalls();
}
public void GenericFactory_CreatesInstances()
{
var collection = new ServiceCollection();
var registeredDependency = new RegisteredDependency {
Value = "registered"
};
var unregisteredDependency = new UnregisteredDependency {
Value = "unregistered"
};
collection.AddTransient <RegisteredDependency>(_ => registeredDependency);
collection.AddFactory <IFoo, Foo, UnregisteredDependency>();
var provider = collection.BuildServiceProvider();
var factory = provider.GetRequiredFactory <IFoo, UnregisteredDependency>();
Assert.NotNull(factory);
var instance = factory.CreateService(unregisteredDependency);
Assert.NotNull(instance);
Assert.IsType <Foo>(instance);
Assert.Same(instance.Registered, registeredDependency);
Assert.Same(instance.Unregistered, unregisteredDependency);
}
/// <summary>
/// Instantiate a new instance of the dependency
/// </summary>
/// <param name="dependency"></param>
private object Instantiate(RegisteredDependency dependency)
{
//Review this later on:
//https://stackoverflow.com/questions/752/get-a-new-object-instance-from-a-type/29239907
ConstructorInfo constructor = null;
try {
constructor = dependency.ResolveType.GetConstructors().First(c => c.GetCustomAttribute <InvertConstructorAttribute>() != null);
}
finally {
if (constructor == null)
{
throw new MissingMethodException(string.Format("No constructor marked with an InjectConstructorAttribute found for type {0}", dependency.ResolveType));
}
}
ParameterInfo[] parameterInfos = constructor.GetParameters();
//Does it have any parameters?
if (parameterInfos.Length == 0)
{
object instance = null;
//Is it a singleton?
if (dependency.IsSingleton)
{
if (singletons.TryGetValue(dependency.ResolveType, out instance))
{
return(instance);
}
else
{
instance = Activator.CreateInstance(dependency.ResolveType);
singletons.Add(dependency.ResolveType, instance);
return(instance);
}
}
else
{
return(Activator.CreateInstance(dependency.ResolveType));
}
}
else
{
List <object> parameters = new List <object>();
for (int i = 0; i < parameterInfos.Length; i++)
{
RegisteredDependency dependencyChild = ResolveDependency(parameterInfos[i].ParameterType);
parameters.Add(Instantiate(dependencyChild));
}
return(Activator.CreateInstance(dependency.ResolveType, parameters.ToArray()));
}
}
/// <summary>
/// Resolve a dependency with the container. If no matching
/// dependency is found, an exception is thrown.
/// </summary>
/// <param name="type">The type to look for.</param>
/// <returns>The found dependency.</returns>
private RegisteredDependency ResolveDependency(Type type)
{
RegisteredDependency dependency = null;
try {
dependency = registeredDependencies[type];
}
catch {
throw new DependencyNotFoundException(type);
}
return(dependency);
}
/// <summary>
/// Register a dependency to the container.
/// </summary>
/// <typeparam name="T">The dependency to register.</typeparam>
/// <returns>The registered wrapper.</returns>
public IRegisteredDependency Register <T>()
{
Type dependencyType = typeof(T);
RegisteredDependency registeredDependency = new RegisteredDependency(dependencyType);
//Check to see if we can add it.
if (!registeredDependencies.TryAdd(dependencyType, registeredDependency))
{
throw new DependencyCollisionException(dependencyType);
}
return(registeredDependency);
}
public void GenericFactory_Correct_CreatesInstances()
{
var registeredDependency = new RegisteredDependency {
Value = "registered"
};
var unregisteredDependency = new UnregisteredDependency {
Value = "unregistered"
};
var expectedInstance = new Foo(registeredDependency, unregisteredDependency);
var weakFactoryMock = new Mock <IWeaklyTypedFactory <IFoo> >();
weakFactoryMock.Setup(m => m.CreateService(unregisteredDependency)).Returns(expectedInstance);
var factory = new GenericFactory <IFoo, UnregisteredDependency>(weakFactoryMock.Object);
var instance = factory.CreateService(unregisteredDependency);
weakFactoryMock.Verify(m => m.CreateService(unregisteredDependency), Times.Once());
weakFactoryMock.VerifyNoOtherCalls();
Assert.Same(expectedInstance, instance);
}
public DependencyCollection GetOrAddCollection(Type t, bool register)
{
if (registeredTypes.TryGetValue(t, out var dependency))
{
if (register)
{
dependency.Registered = true;
}
return(dependency.Collection);
}
dependency = new RegisteredDependency()
{
Registered = register
};
registeredTypes.Add(t, dependency);
return(dependency.Collection);
}
