public override TImpl ResolveTypedInstance()
{
var injector = InjectorCache.GetOrCreateInjector(typeof(TImpl));
var instance = injector.CreateInstance <TImpl>(diContainer);
return(instance);
}
private void AddInjectorDependencies(InjectionKey injected)
{
var injector = InjectorCache.GetOrCreateInjector(injected.InjectedResourceType);
foreach (var dependsOn in injector.DependsOn)
{
AddDependency(injected, dependsOn, false);
}
}
public virtual IRegistration Build()
{
var injector = InjectorCache.GetOrBuild(ImplementationType);
return(new Registration(
ImplementationType,
Lifetime,
InterfaceTypes,
Parameters,
injector));
}
public override IRegistration Build()
{
var injector = InjectorCache.GetOrBuild(ImplementationType);
return(new SystemRegistration(
ImplementationType,
InterfaceTypes,
Parameters,
injector,
worldName,
systemGroupType));
}
public override IRegistration Build()
{
var injector = InjectorCache.GetOrBuild(ImplementationType);
var destination = new ComponentDestination(prefab, parent, parentFinder, gameObjectName);
return(new ComponentRegistration(
ImplementationType,
Lifetime,
InterfaceTypes,
Parameters,
injector,
destination));
}
public void CircularDependency()
{
var builder = new ContainerBuilder();
builder.Register <HasCircularDependency1>(Lifetime.Transient);
builder.Register <HasCircularDependency2>(Lifetime.Transient);
var injector = InjectorCache.GetOrBuild(typeof(HasCircularDependency1));
// Only reflection mode can detect circular dependency errors at runtime.
if (injector is ReflectionInjector)
{
// Assert.Throws<AggregateException>(() => builder.Build());
Assert.Throws <VContainerException>(() => builder.Build(),
"Circular dependency detected! type: VContainer.Tests.HasCircularDependency1");
}
}
public void TestInjectorCache()
{
InjectorCache.ClearCache();
//Should reuse the first instance of an injector
var instance = InjectorCache.GetOrCreateInjector(typeof(IInterface));
Assert.IsNotNull(instance, "Injector instance should not be null");
Assert.AreEqual(1, InjectorCache.CachedInjectorCount);
var secondInstance = InjectorCache.GetOrCreateInjector(typeof(IInterface));
Assert.AreEqual(1, InjectorCache.CachedInjectorCount);
Assert.IsTrue(ReferenceEquals(instance, secondInstance), "Should reuse injector instance!");
//Clear should reset to zero
InjectorCache.ClearCache();
Assert.AreEqual(0, InjectorCache.CachedInjectorCount);
}
public void Inject(object instance, params IInjectParameter[] parameters)
{
var injector = InjectorCache.GetOrBuild(instance.GetType());
injector.Inject(instance, this, parameters);
}
public void Inject(object instance)
{
var injector = InjectorCache.GetOrBuild(instance.GetType());
injector.Inject(instance, this, null);
}
private void InjectObject(object targe, IDictionary <Type, object> tempDependencys, IDictionary <string, GameObject> tempGameObjectDependencys)
{
InjectorCache cache;
var type = targe.GetType();
if (!injectorCache.TryGetValue(type, out cache))
{
var methodInfo = type.GetMethod("Construct", BindingFlags.Public | BindingFlags.Instance);
ParameterInfo[] parameters = null;
if (methodInfo != null && (parameters = methodInfo.GetParameters()).Length != 0)
{
cache = new InjectorCache(methodInfo, parameters);
}
injectorCache.Add(type, cache);
}
if (cache == null)
{
return;
}
var args = new object[cache.Parameters.Length];
var missingParameters = new List <ParameterInfo>(cache.Parameters.Length);
for (int i = 0; i < args.Length; i++)
{
var parameter = cache.Parameters[i];
var isGameObject = parameter.ParameterType == typeof(GameObject);
args[i] = isGameObject ?
this.GetGameObject(parameter.Name) :
this.Get(parameter.ParameterType);
if (args[i] != null)
{
continue;
}
if (isGameObject && tempGameObjectDependencys != null)
{
GameObject temp = null;
if (tempGameObjectDependencys.TryGetValue(parameter.Name, out temp))
{
args[i] = temp;
continue;
}
}
else if (tempDependencys != null)
{
object temp = null;
if (tempDependencys.TryGetValue(parameter.ParameterType, out temp))
{
args[i] = temp;
continue;
}
}
if (!cache.IsParameterOpenal(i))
{
missingParameters.Add(parameter);
}
}
if (missingParameters.Count != 0)
{
throw new DependencyMissingException(type, missingParameters);
}
cache.MethodInfo.Invoke(targe, args);
}
