public object Instantiate(
Type concreteType, params object[] extraArgs)
{
Assert.That(!extraArgs.Contains(null),
"Null value given to factory constructor arguments when instantiating object with type '{0}'. In order to use null use InstantiateExplicit", concreteType);
return(InstantiateExplicit(
concreteType, InstantiateUtil.CreateTypeValueList(extraArgs)));
}
internal static void Inject(
DiContainer container, object injectable,
IEnumerable <object> additional, bool shouldUseAll, ZenjectTypeInfo typeInfo)
{
Assert.That(!additional.Contains(null),
"Null value given to injection argument list. In order to use null you must provide a List<TypeValuePair> and not just a list of objects");
Inject(
container, injectable,
InstantiateUtil.CreateTypeValueList(additional), shouldUseAll, typeInfo);
}
object InstantiateInternal(
Type concreteType, IEnumerable <TypeValuePair> extraArgMapParam)
{
Assert.That(!concreteType.DerivesFrom <UnityEngine.Component>(),
"Error occurred while instantiating object of type '{0}'. Instantiator should not be used to create new mono behaviours. Must use GameObjectInstantiator, GameObjectFactory, or GameObject.Instantiate.", concreteType.Name());
var typeInfo = TypeAnalyzer.GetInfo(concreteType);
if (typeInfo.InjectConstructor == null)
{
throw new ZenjectResolveException(
"More than one or zero constructors found for type '{0}' when creating dependencies. Use one [Inject] attribute to specify which to use.".With(concreteType));
}
// Make a copy since we remove from it below
var extraArgMap = extraArgMapParam.ToList();
var paramValues = new List <object>();
foreach (var injectInfo in typeInfo.ConstructorInjectables)
{
object value;
if (!InstantiateUtil.PopValueWithType(extraArgMap, injectInfo.ContractType, out value))
{
value = _container.Resolve(injectInfo);
}
paramValues.Add(value);
}
object newObj;
try
{
using (ProfileBlock.Start("{0}.{0}()", concreteType))
{
newObj = typeInfo.InjectConstructor.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, extraArgMap, true, typeInfo);
return(newObj);
}
internal static void Inject(
DiContainer container, object injectable,
IEnumerable <TypeValuePair> extraArgMapParam, bool shouldUseAll, ZenjectTypeInfo typeInfo)
{
Assert.IsEqual(typeInfo.TypeAnalyzed, injectable.GetType());
Assert.That(injectable != null);
// Make a copy since we remove from it below
var extraArgMap = extraArgMapParam.ToList();
foreach (var injectInfo in typeInfo.FieldInjectables.Concat(typeInfo.PropertyInjectables))
{
object value;
if (InstantiateUtil.PopValueWithType(extraArgMap, injectInfo.ContractType, out value))
{
injectInfo.Setter(injectable, value);
}
else
{
value = container.Resolve(injectInfo, injectable);
if (injectInfo.Optional && value == null)
{
// Do not override in this case so it retains the hard-coded value
}
else
{
injectInfo.Setter(injectable, value);
}
}
}
if (shouldUseAll && !extraArgMap.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(",", extraArgMap.Select(x => x.Type.Name()).ToArray()), DiContainer.GetCurrentObjectGraph()));
}
foreach (var methodInfo in typeInfo.PostInjectMethods)
{
using (ProfileBlock.Start("{0}.{1}()", injectable.GetType(), methodInfo.Name))
{
methodInfo.Invoke(injectable, new object[0]);
}
}
}