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)));
}
public void Inject(
object injectable,
IEnumerable <object> additional, bool shouldUseAll, InjectContext context, 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");
InjectExplicit(
injectable, InstantiateUtil.CreateTypeValueList(additional), shouldUseAll, typeInfo, context, null);
}
object InstantiateInternal(
Type concreteType, IEnumerable <TypeValuePair> extraArgMapParam, InjectContext currentContext)
{
#if !ZEN_NOT_UNITY3D
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());
#endif
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.".Fmt(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.MemberType, out value))
{
value = Resolve(injectInfo.CreateInjectContext(this, currentContext, null));
}
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}'".Fmt(concreteType.Name()), e);
}
Inject(newObj, extraArgMap, true, typeInfo, currentContext);
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]);
}
}
}
// Iterate over fields/properties on the given object and inject any with the [Inject] attribute
internal void Inject(
object injectable, IEnumerable <TypeValuePair> extraArgMapParam,
bool shouldUseAll, ZenjectTypeInfo typeInfo, InjectContext context)
{
Assert.IsEqual(typeInfo.TypeAnalyzed, injectable.GetType());
Assert.That(injectable != null);
#if !ZEN_NOT_UNITY3D
Assert.That(injectable.GetType() != typeof(GameObject),
"Use InjectGameObject to Inject game objects instead of Inject method");
#endif
// 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.MemberType, out value))
{
injectInfo.Setter(injectable, value);
}
else
{
value = Resolve(
injectInfo.CreateInjectContext(this, context, injectable));
if (injectInfo.Optional && value == null)
{
// Do not override in this case so it retains the hard-coded value
}
else
{
injectInfo.Setter(injectable, value);
}
}
}
foreach (var method in typeInfo.PostInjectMethods)
{
using (ProfileBlock.Start("{0}.{1}()", injectable.GetType(), method.MethodInfo.Name))
{
var paramValues = new List <object>();
foreach (var injectInfo in method.InjectableInfo)
{
object value;
if (!InstantiateUtil.PopValueWithType(extraArgMap, injectInfo.MemberType, out value))
{
value = Resolve(
injectInfo.CreateInjectContext(this, context, injectable));
}
paramValues.Add(value);
}
method.MethodInfo.Invoke(injectable, paramValues.ToArray());
}
}
if (shouldUseAll && !extraArgMap.IsEmpty())
{
throw new ZenjectResolveException(
"Passed unnecessary parameters when injecting into type '{0}'. \nExtra Parameters: {1}\nObject graph:\n{2}"
.Fmt(injectable.GetType().Name(), String.Join(",", extraArgMap.Select(x => x.Type.Name()).ToArray()), context.GetObjectGraphString()));
}
}
object InstantiateInternal(
Type concreteType, IEnumerable <TypeValuePair> extraArgs, InjectContext currentContext, string concreteIdentifier, bool autoInject)
{
#if !ZEN_NOT_UNITY3D
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 InstantiatePrefabForComponent, InstantiatePrefab, InstantiateComponentOnNewGameObject, InstantiateGameObject, or InstantiateComponent. You may also want to use GameObjectFactory class or plain old GameObject.Instantiate.", concreteType.Name());
#endif
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.".Fmt(concreteType));
}
// Make a copy since we remove from it below
var extraArgList = extraArgs.ToList();
var paramValues = new List <object>();
foreach (var injectInfo in typeInfo.ConstructorInjectables)
{
object value;
if (!InstantiateUtil.PopValueWithType(extraArgList, injectInfo.MemberType, out value))
{
value = Resolve(injectInfo.CreateInjectContext(this, currentContext, null, concreteIdentifier));
}
paramValues.Add(value);
}
object newObj;
try
{
#if PROFILING_ENABLED
using (ProfileBlock.Start("{0}.{0}()", concreteType))
#endif
{
newObj = typeInfo.InjectConstructor.Invoke(paramValues.ToArray());
}
}
catch (Exception e)
{
throw new ZenjectResolveException(
"Error occurred while instantiating object with type '{0}'".Fmt(concreteType.Name()), e);
}
if (autoInject)
{
InjectExplicit(newObj, extraArgList, true, typeInfo, currentContext, concreteIdentifier);
}
else
{
if (!extraArgList.IsEmpty())
{
throw new ZenjectResolveException(
"Passed unnecessary parameters when injecting into type '{0}'. \nExtra Parameters: {1}\nObject graph:\n{2}"
.Fmt(newObj.GetType().Name(), String.Join(",", extraArgList.Select(x => x.Type.Name()).ToArray()), currentContext.GetObjectGraphString()));
}
}
return(newObj);
}
