public ArgKernel(IGetKernel kernel, BindArg[] args)
{
_kernel = kernel;
_args = args;
Root = _kernel.Root;
_lastCacheOkVersion = Root.Version;
}
public static void Inject(this IGetKernel kernel, object instance)
{
if (instance == null)
{
return;
}
kernel.GetInjector(instance.GetType())?.Invoke(kernel, instance);
}
public static object[] GetValues(this ParameterInfo[] parameters, IGetKernel kernel)
{
return(parameters.ConvertAll(p => kernel.GetArg(p.ParameterType, p.Name)));
//var pi = parameters.ParameterInfo;
//return pi.Length <= 2 ?
// Array.ConvertAll(pi, p => kernel.Arg(p.ParameterType, p.Name))
// : pi.AsParallel().Select(p => kernel.Arg(p.ParameterType, p.Name)).ToArray();
}
public static object GetDefault(this IGetKernel kernel, Type type)
{
var binding = kernel.GetDefaultBinding(type);
if (binding == null)
{
throw new InvalidOperationException("Can't GetDefault: " + type + " no default binding found");
}
return(binding(kernel));
}
public static object GetArg(this IGetKernel kernel, Type type, string name)
{
var binding = kernel.GetArgBinding(type, name);
if (binding == null)
{
throw new InvalidOperationException("Can't GetArg: " + type + " for arg " + name + " no binding found");
}
return(binding(kernel));
}
public static object Get(this IGetKernel kernel, Type type, params BindArg[] args)
{
if (args == null || args.Length == 0)
{
return(kernel.Get(type));
}
var argKernel = new ArgKernel(kernel, args);
return(argKernel.Get(type));
}
public static object Get(this IGetKernel kernel, Type type)
{
// Binding should inject - for singletons, consts, etc.
var binding = kernel.GetBinding(type);
if (binding == null)
{
throw new InvalidOperationException("Can't Get: " + type + " no binding found");
}
return(binding(kernel));
}
public Binding CreateDefaultBinding(Type type, IGetKernel kernel)
{
foreach (var defaultBuilder in _defaultBuilders)
{
var binding = defaultBuilder(type, kernel);
if (binding != null)
{
return(binding);
}
}
return(DefaultBindingBuilder.CreateDefaultBinding(type, kernel));
}
public Binding TryBind <TInner>(IGetKernel kernel)
{
return(c =>
{
var bindings = c.Root.GetUserBindings(typeof(TInner));
var result = new TInner[bindings.Count];
var i = 0;
foreach (var binding in bindings)
{
result[i++] = (TInner)binding(c);
}
return result;
});
}
public Binding TryBind <TInner>(IGetKernel kernel)
{
return(c =>
{
var bindings = c.Root.GetUserBindings(typeof(TInner));
var result = new List <TInner>(bindings.Count);
// ReSharper disable once LoopCanBeConvertedToQuery
// ReSharper disable once ForCanBeConvertedToForeach
foreach (var binding in bindings)
{
result.Add((TInner)binding(c));
}
return result;
});
}
public object Get(IGetKernel kernel)
{
if (_firstCalled)
{
return(_value);
}
lock (_firstCall)
{
if (_firstCalled)
{
return(_value);
}
// execute on root kernel!
_value = _firstCall(kernel.Root);
_firstCalled = true;
}
return(_value);
}
public static Injector CreateDefaultInjector(Type type, IGetKernel kernel)
{
var methods = GetMethods(type);
if (methods == null || methods.Length == 0)
{
return(NullInjector);
}
var method = ChooseMethod(methods, kernel);
if (method == null)
{
return(NullInjector);
}
return((c, instance) => method.Invoke(instance, c));
}
private static FastMethod ChooseMethod(FastMethod[] methods, IGetKernel kernel)
{
foreach (var method in methods)
{
var cantBind = method.Parameters.CantBindFirst(kernel);
if (cantBind == null)
{
return(method);
}
Debug.Print("ChooseMethod: Can't use method {0} for injecting type {1}: Failed to bind parameter {2}",
method,
method.MethodInfo.DeclaringType,
cantBind);
}
return(null);
}
public Binding TryBuild(Type type, IGetKernel kernel)
{
Type definition;
Type arg;
if (type.TypeInfo().IsGenericType)
{
var args = type.GenericTypeArguments;
if (args.Length != 1)
{
return(null);
}
definition = type.GetGenericTypeDefinition();
arg = args[0];
}
else if (type.IsArray)
{
definition = typeof(Array);
arg = type.GetElementType();
if (arg == null)
{
return(null);
}
}
else
{
return(null);
}
IGenericDefaultBuilder builder;
if (!_builders.TryGetValue(definition, out builder))
{
return(null);
}
var invoker = GetInvoker(arg);
return(invoker(builder, kernel));
}
public static Binding CreateDefaultBinding(Type impl, IGetKernel kernel,
Func <FastConstructor, bool> filter = null)
{
// TODO: remove filter?
if (_noDefaultBindings.Contains(impl))
{
return(null);
}
var constructors = GetConstructors(impl);
if (constructors == null)
{
return(null);
}
var constructor = ChooseConstructor(constructors, kernel, filter);
if (constructor == null && filter != null)
{
constructor = ChooseConstructor(constructors, kernel);
}
if (constructor == null)
{
return(null);
}
//var injector = kernel.GetInjector(impl);
return(c =>
{
var instance = constructor.Invoke(c);
c.Inject(instance);
return instance;
});
}
private static void NullInjector(IGetKernel kernel, object o)
{
}
//public static IBinding CreateDefaultBinding<T>(IArgKernel kernel)
//{
// return CreateDefaultBinding(typeof(T), kernel);
//}
private static FastConstructor ChooseConstructor(FastConstructor[] paramConstructors, IGetKernel kernel,
Func <FastConstructor, bool> filter = null)
{
var constructors = filter != null?paramConstructors.Where(filter) : paramConstructors;
foreach (var constructor in constructors)
{
var cantBind = constructor.Parameters.CantBindFirst(kernel);
if (cantBind == null)
{
return(constructor);
}
Debug.Print("ChooseConstructor: Can't use constructor {0} for building type {1}: Failed to bind parameter {2}",
constructor,
constructor.ConstructorInfo.DeclaringType,
cantBind);
}
return(null);
//throw Exception("No suitable constructor found for {0}(implementation for {1})", impl, type);
}
public static ParameterInfo CantBindFirst(this ParameterInfo[] parameters, IGetKernel kernel)
{
return(Array.Find(parameters, p => !kernel.CanBindArg(p.ParameterType, p.Name)));
}
public static T Get <T>(this IGetKernel kernel)
{
return((T)kernel.Get(typeof(T)));
}
public static object Invoke(this FastConstructor constructor, IGetKernel kernel)
{
var args = constructor.Parameters.GetValues(kernel);
return(constructor.Invoke(args));
}
public Binding TryBind <TInner>(IGetKernel kernel)
{
return(c => (Func <TInner>)c.Get <TInner>);
}
public static bool CanBindArg(this IGetKernel kernel, Type type, string name)
{
return(kernel.GetArgBinding(type, name) != null);
}
/// <summary>
/// Returns binding for argument
/// </summary>
private static Binding GetArgBinding(this IGetKernel kernel, Type type, string name)
{
return(kernel.GetOverrideBinding(type, name) ?? kernel.GetBinding(type));
}
public static T Get <T>(this IGetKernel kernel, params BindArg[] args)
{
return((T)kernel.Get(typeof(T), args));
}
public static Binding GetBinding(this IGetKernel kernel, Type type)
{
// user binding has priority
return(kernel.Root.GetUserBinding(type) ?? kernel.GetDefaultBinding(type));
}
// For syntax compatibility with NInject
public static T Inject <T>(this IGetKernel kernel)
{
return(kernel.Get <T>());
}
public static void Invoke(this FastMethod method, object instance, IGetKernel kernel)
{
var args = method.Parameters.GetValues(kernel);
method.Invoke(instance, args);
}
public Injector CreateDefaultInjector(Type type, IGetKernel kernel)
{
return(DefaultInjectorBuilder.CreateDefaultInjector(type, kernel));
}
public static bool CanBind(this IGetKernel kernel, Type type)
{
return(kernel.GetBinding(type) != null);
}
