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); }