public IFactoryExpression Resolve(IFactoryFinder factoryFinder)
{
var constructedType = _delegateInfo.InvokeMethod.ReturnType;
if (constructedType == typeof(void) || _delegateInfo.InvokeMethod.GetParameters().Any())
{
throw new NonFactoryDelegateException(_delegateInfo);
}
var service = new Service(constructedType).Resolve(factoryFinder);
return(new FactoryExpression(lifeScope =>
{
var closure = new Closure();
var nestedScopeClosure = Expression.Property(Expression.Constant(closure), nameof(Closure.LifeScope));
var body = service.GetBody(nestedScopeClosure);
var factory = Expression.Lambda(_delegateInfo.Type, body).Compile();
var returnTarget = Expression.Label(_delegateInfo.Type);
return Expression.Block(
Expression.Assign(nestedScopeClosure, Expression.Call(lifeScope, CreateNestedScopeMethod)),
Expression.Label(returnTarget, Expression.Constant(factory)));
}));
}
public ObjectFactoriesProcessor(ILog log, IAssemblies assemblies, IFactoryFinder factoryFinder, IConstructorCallFinder constructorCallFinder, IFactoryCallWeaver factoryCallWeaver, IFactoryMapSerializer factoryMapSerializer)
{
_log = log;
_factoryMapSerializer = factoryMapSerializer;
_assemblies = assemblies;
_factoryCallWeaver = factoryCallWeaver;
_constructorCallFinder = constructorCallFinder;
_factoryFinder = factoryFinder;
}
public ObjectFactoriesProcessor(ILog log, IAssemblies assemblies, IFactoryFinder factoryFinder, IConstructorCallFinder constructorCallFinder, IFactoryCallWeaver factoryCallWeaver, IFactoryMapSerializer factoryMapSerializer)
{
_log = log;
_factoryMapSerializer = factoryMapSerializer;
_assemblies = assemblies;
_factoryCallWeaver = factoryCallWeaver;
_constructorCallFinder = constructorCallFinder;
_factoryFinder = factoryFinder;
}
public override ObjectFactoriesProcessor Create()
{
_assembly = _mocks.DynamicMock <IAssembly>();
_assemblies = _mocks.DynamicMock <IAssemblies>();
_factoryFinder = _mocks.DynamicMock <IFactoryFinder>();
_constructorCallFinder = _mocks.DynamicMock <IConstructorCallFinder>();
_factoryCallWeaver = _mocks.DynamicMock <IFactoryCallWeaver>();
_factoryMapSerializer = _mocks.DynamicMock <IFactoryMapSerializer>();
return(new ObjectFactoriesProcessor(new NullLogger(), _assemblies, _factoryFinder, _constructorCallFinder, _factoryCallWeaver, _factoryMapSerializer));
}
public IFactoryExpression Resolve(IFactoryFinder factoryFinder)
{
var serviceType = _lazyType.GenericTypeArguments[0];
var serviceFactoryDelegateInfo = typeof(Func <>).MakeGenericType(serviceType).AsDelegate();
var lazyConstructor = _lazyType.GetTypeInfo().GetConstructor(new[] { serviceFactoryDelegateInfo.Type });
var factory = new ServiceFactory(serviceFactoryDelegateInfo).Resolve(factoryFinder);
return(new FactoryExpression(lifeScope => Expression.New(lazyConstructor, factory.GetBody(lifeScope))));
}
public IFactoryExpression Resolve(IFactoryFinder factoryFinder)
{
if (factoryFinder.TryGetFactory(_type, out var factoryExpression))
{
return(factoryExpression);
}
if (_type.GetTypeInfo().IsGenericType)
{
return(new GenericService(_type).Resolve(factoryFinder));
}
throw new NotRegisteredDependencyException(_type);
}
public IFactoryExpression Resolve(IFactoryFinder factoryFinder)
{
if (!IsConcreteClass(_type))
{
throw new NonConcreteClassException(_type);
}
var constructor = GetSinglePublicConstructor(_type);
var resolvedDependencies = ResolveDependencies(constructor, factoryFinder).ToList();
if (DisposableType.IsAssignableFrom(_type))
{
return(ResolveDisposable(constructor, resolvedDependencies));
}
return(ResolveNonDisposable(constructor, resolvedDependencies));
}
public IFactoryExpression Resolve(IFactoryFinder factoryFinder)
{
var serviceTypeDefinition = _type.GetGenericTypeDefinition();
if (!factoryFinder.TryGetGenericType(serviceTypeDefinition, out var implementationTypeDefinition))
{
if (IsGenericSequence(_type))
{
throw new NotRegisteredSequenceDependencyException(_type);
}
throw new NotRegisteredDependencyException(_type);
}
var implementationType =
implementationTypeDefinition.MakeGenericType(_type.GetTypeInfo().GetGenericArguments());
return(new Implementation(implementationType).Resolve(factoryFinder));
}
private IFactoryExpression ResolveDependency(Type type, IFactoryFinder factoryFinder)
{
try
{
if (type.GetTypeInfo().IsGenericType&& typeof(Lazy <>) == type.GetGenericTypeDefinition())
{
return(new LazyService(type).Resolve(factoryFinder));
}
var delegateInfo = type.AsDelegate();
if (delegateInfo != null)
{
return(new ServiceFactory(delegateInfo).Resolve(factoryFinder));
}
return(new Service(type).Resolve(factoryFinder));
}
catch (RegistrationException e)
{
throw new DependencyRegistrationException(_type, e);
}
}
public Resolver(IFactoryFinder factoryFinder)
{
_factoryFinder = factoryFinder;
}
private IEnumerable <IFactoryExpression> ResolveDependencies(
ConstructorInfo constructor,
IFactoryFinder factoryFinder)
{
return(GetDependencies(constructor).Select(d => ResolveDependency(d, factoryFinder)));
}
