private DependencyLocator GetNewLocator_Func_5 <T1, T2, T3, T4, TResult>(ActivatorTree tree)
{
tree = new ActivatorTree(tree, tree.Context.Get(typeof(TResult), new MethodSignature(typeof(T1), typeof(T2), typeof(T3), typeof(T4))));
var locator = GetLocator(tree);
return((c, a) => new Func <T1, T2, T3, T4, TResult>((t1, t2, t3, t4) => (TResult)locator(c, new object[] { t1, t2, t3, t4 })));
}
private DependencyLocator GetNewLocator_Func_2 <T, TResult>(ActivatorTree tree)
{
tree = new ActivatorTree(tree, tree.Context.Get(typeof(TResult), new MethodSignature(typeof(T))));
var locator = GetLocator(tree);
return((c, a) => new Func <T, TResult>((t) => (TResult)locator(c, new object[] { t })));
}
private DependencyLocator GetNewLocator_Func_1 <T>(ActivatorTree tree)
{
tree = new ActivatorTree(tree, tree.Context.Get(typeof(T)));
var locator = GetLocator(tree);
return((c, a) => new Func <T>(() => (T)locator(c, a)));
}
public void Inject(object obj, object[] args, IRuntimeImportContext ctx)
{
var tree = new ActivatorTree(null, ctx.StaticContext);
tree.Key = new ActivatorKey(obj.GetType(), null);
var injectors = GetClassInjector(tree);
injectors.Item1(ctx, args, obj);
injectors.Item2(ctx, args, obj);
}
private DependencyLocator GetNewLocator_IEnumerable_1 <T>(IActivatorTree tree)
{
Action <IRuntimeImportContext, object[], List <T> > action = (c, a, l) => {};
var testTree = new ActivatorTree(tree, tree.Context.Get(typeof(T)));
foreach (var e in _locatorEntries.Where(l => l.Test(testTree)).ToList())
{
var activator = e.Locator(new ActivatorTree(tree, tree.Context.Get(typeof(T))));
action += (c, a, l) => l.Add((T)activator(c, a));
}
return((c, a) =>
{
var l = new List <T>();
action(c, a, l);
return l;
});
}
private DependencyLocator GetNewLocator(IActivatorTree tree)
{
var importType = tree.Context.ImportType;
if (importType.IsGenericType)
{
var g = importType.GetGenericTypeDefinition();
var args = importType.GetGenericArguments();
// return a Func<Type,object> to provide generic locator without arguments
if (args.Length == 2 && args[0] == typeof(Type) && args[1] == typeof(object))
{
return((c, a) => new Func <Type, object>(t => Locate(c.Get(c.Target, tree.Context.Get(t, null)))));
}
//return a Func<Type,object[],object> to provide a generic locator with arguments
if (args.Length == 3 && args[0] == typeof(Type) && args[1] == typeof(object[]) && args[2] == typeof(object))
{
return((c, a) => new Func <Type, object[], object>((t, ar) =>
{
var types = new MethodSignature(ar);
return Locate(c.Get(c.Target, tree.Context.Get(t, types)), ar);
}));
}
var name = g.Name.Split('`')[0];
var mi = GetType().GetMethod("GetNewLocator_" + name + "_" + args.Length, BindingFlags.NonPublic | BindingFlags.Instance);
if (mi != null)
{
var m = mi.MakeGenericMethod(args);
var r = m?.Invoke(this, new object[] { tree });
if (r is DependencyLocator l)
{
return(l);
}
throw new Exception("");
}
}
{
var decorators = _decoratorEntries.Where(e => e.Test(tree));
var exportEntry = _locatorEntries.Get(e => e.Test(tree));
//if (tree.Context.ImportType.Name.Contains("ErpServices"))
//{
// foreach (var e in _locatorEntries)
// {
// if (e.ExportType(tree).Name.Contains("ErpServices"))
// { }
// var r = e.Test(tree);
// }
//}
IActivatorKey export;
ExportMode mode;
// when no export entry found but type is instantiable use it TODO : should be an option
if (exportEntry == null)
{
if (!importType.IsAbstract && !importType.IsInterface)
{
exportEntry = new ExportEntry(this)
{
ExportType = t => importType
};
export = new ActivatorKey(importType, tree.Context.Signature);
mode = ExportMode.Default;
}
else
{
var t = new ActivatorTree(null, new ImportContext());
var n = _locatorEntries.Get(e =>
{
try
{
var exportType = e.ExportType(t);
return(importType.IsAssignableFrom(exportType));
}
catch
{
return(false);
}
});
throw new Exception("Unable to locate " + tree.ToString() /*importType.GenericReadableName()*/);
}
}
else
{
export = exportEntry.GetActivatorKey(tree);
mode = exportEntry.Mode;
}
DependencyLocator activator;
if (mode.HasFlag(ExportMode.Singleton))
{
var type = export.ReturnType;
tree.Key = new ActivatorKey(type, null);
var singleton = Singletons.GetOrAdd(type, t => exportEntry.Locator(tree)(RuntimeImportContext.GetStatic(null, tree.Context.ImportType), null));
activator = (c, a) => singleton;
}
else
{
activator = exportEntry.Locator(tree);
}
foreach (var de in decorators)
{
var decorator = de.Locator(new ActivatorTree(tree,
tree.Context.Get(importType, new MethodSignature(importType))));
var old = activator;
activator = (c, a) => decorator(c, new[] { old(c, a) });
}
return(activator);
}
}
