public static IEnumerable <ZenjectResolveException> ValidateObjectGraph(
DiContainer container, Type concreteType, params Type[] extras)
{
using (container.PushLookup(concreteType))
{
var dependencies = InjectablesFinder.GetAllInjectables(concreteType);
var extrasList = extras.ToList();
foreach (var dependInfo in dependencies)
{
Assert.IsEqual(dependInfo.EnclosingType, concreteType);
if (TryTakingFromExtras(dependInfo.ContractType, extrasList))
{
continue;
}
var context = new ResolveContext(
dependInfo, container.LookupsInProgress.ToList(), null);
foreach (var error in ValidateContract(
container, dependInfo.ContractType, context, dependInfo.Optional))
{
yield return(error);
}
}
if (!extrasList.IsEmpty())
{
yield return(new ZenjectResolveException(
"Found unnecessary extra parameters passed when injecting into '{0}' with types '{1}'. \nObject graph:\n{2}"
.With(concreteType.Name(), String.Join(",", extrasList.Select(x => x.Name()).ToArray()), container.GetCurrentObjectGraph())));
}
}
}
public static void Inject(DiContainer container, object injectable, IEnumerable <object> additional, bool shouldUseAll)
{
Assert.That(injectable != null);
var additionalCopy = additional.ToList();
var injectInfos = InjectablesFinder.GetFieldAndPropertyInjectables(injectable.GetType());
foreach (var injectInfo in injectInfos)
{
bool didInject = InjectFromExtras(injectInfo, injectable, additionalCopy);
if (!didInject)
{
InjectFromResolve(injectInfo, container, injectable);
}
}
if (shouldUseAll && !additionalCopy.IsEmpty())
{
throw new ZenjectResolveException(
"Passed unnecessary parameters when injecting into type '{0}'. \nExtra Parameters: {1}\nObject graph:\n{2}"
.With(injectable.GetType().Name(), String.Join(",", additionalCopy.Select(x => x.GetType().Name()).ToArray()), container.GetCurrentObjectGraph()));
}
foreach (var methodInfo in InjectablesFinder.GetPostInjectMethods(injectable.GetType()))
{
methodInfo.Invoke(injectable, new object[0]);
}
}
public IEnumerable <Type> GetDependencyContracts(Type contract)
{
Assert.That(!_hasDisposed);
foreach (var injectMember in InjectablesFinder.GetAllInjectables(contract, false))
{
yield return(injectMember.ContractType);
}
}
object InstantiateInternal(
Type concreteType, params object[] constructorArgs)
{
ConstructorInfo method;
var injectInfos = InjectablesFinder.GetConstructorInjectables(concreteType, out method);
var paramValues = new List <object>();
var extrasList = new List <object>(constructorArgs);
Assert.That(!extrasList.Contains(null),
"Null value given to factory constructor arguments. This is currently not allowed");
foreach (var injectInfo in injectInfos)
{
var found = false;
foreach (var extra in extrasList)
{
if (extra.GetType().DerivesFromOrEqual(injectInfo.ContractType))
{
found = true;
paramValues.Add(extra);
extrasList.Remove(extra);
break;
}
}
if (!found)
{
paramValues.Add(_container.Resolve(injectInfo));
}
}
object newObj;
try
{
newObj = method.Invoke(paramValues.ToArray());
}
catch (Exception e)
{
throw new ZenjectResolveException(
"Error occurred while instantiating object with type '{0}'".With(concreteType.Name()), e);
}
FieldsInjecter.Inject(_container, newObj, extrasList, true);
return(newObj);
}
