/// <summary> /// Returns a value indicating whether the specified member should be injected. /// </summary> /// <param name="member">The member in question.</param> /// <returns> /// <see langword="true"/> if the member should be injected; otherwise <see langword="false"/>. /// </returns> public bool ShouldInject(MemberInfo member) { if (member.MemberType != MemberTypes.Property) { return(false); } var propertyInfo = member as PropertyInfo; if (propertyInfo == null) { return(false); } if (propertyInfo.GetSetMethod() == null) { return(false); } // If the types are the same, or if the property is an interface or abstract class // that the declaring type implements (which would cause a cyclic resolution) if ((propertyInfo.PropertyType == propertyInfo.DeclaringType) || ((propertyInfo.DeclaringType.IsAssignableFrom(propertyInfo.PropertyType)))) { return(false); } var request = _kernel.CreateRequest(propertyInfo.PropertyType, null, EmptyParameters, true, false); return(_kernel.CanResolve(request)); }
/// <summary> /// Determines whether a binding exists between the specified service and concrete types. /// </summary> public bool HasDependencyImplementation(Type serviceType, Type concreteType) { if (serviceType == null || concreteType == null) { return(false); } if (serviceType == concreteType) { return(HasDependency(serviceType)); } var bindings = GetBindings(serviceType); var request = _kernel.CreateRequest(serviceType, null, EmptyParameters, false, false); return(bindings.Any(b => { if (b.Target != BindingTarget.Type) { return false; } var context = new Context(_kernel, request, b, _kernel.Components.Get <ICache>(), _kernel.Components.Get <IPlanner>(), _kernel.Components.Get <IPipeline>()); return b.GetProvider(context).Type == concreteType; })); }
private object GetService(Type serviceType) { //Реализация подсмотрена здесь https://github.com/ninject/Ninject.Web.Mvc/blob/master/mvc3/src/Ninject.Web.Mvc/NinjectDependencyResolver.cs var request = _kernel.CreateRequest(serviceType, null, new Parameter[0], true, true); return(_kernel.Resolve(request).SingleOrDefault()); }
public bool can_resolve_type(Type type) { ConfigureKernel(); var request = kernel.CreateRequest(type, x => true, new IParameter[] { }, false, false); bool canResolveRequest = kernel.CanResolve(request); return(canResolveRequest); }
private static void TryGetSyncHandler <TResult>(IKernel scope, IQuery <TResult> query, out object handler) { var asyncGenericType = typeof(IQueryHandler <,>); var closedAsyncGeneric = asyncGenericType.MakeGenericType(query.GetType(), typeof(TResult)); IRequest request = scope.CreateRequest(closedAsyncGeneric, null, new Parameter[0], true, true); handler = scope.Resolve(request).SingleOrDefault(); }
private object GetExportedValue(IBinding binding) { bool Constraint(IBindingMetadata bindingMetadata) { return(bindingMetadata == binding.Metadata); } var request = _kernel.CreateRequest(binding.Service, Constraint, binding.Parameters, false, true); var result = _kernel.Resolve(request).Single(); return(result); }
public KernelBootstrapperTests() { kernel = Substitute.For <IKernel>(); kernel.WhenForAnyArgs(x => x.Load((IEnumerable <INinjectModule>)null)).Do(ci => loadedModules.AddRange(ci.ArgAt <IEnumerable <INinjectModule> >(0))); kernel.CreateRequest(null, null, null, false, false).ReturnsForAnyArgs(ci => { var request = Substitute.For <IRequest>(); request.Service.Returns(ci.ArgAt <Type>(0)); return(request); }); revoConfiguration = Substitute.For <IRevoConfiguration>(); revoConfiguration.GetSection <KernelConfigurationSection>().Returns(kernelConfigurationSection); sut = new KernelBootstrapper(kernel, revoConfiguration); }
/// <summary> /// Determines whether the specified request can be resolved. /// </summary> /// <param name="service">The specified service type.</param> /// <param name="name">The specified binding name.</param> /// <returns> /// <c>True</c> if the specified service has been resolved; otherwise, <c>false</c>. /// </returns> public bool CanResolve(Type service, string name = null) { Should.NotBeNull(service, "service"); if (IsDisposed) { return(false); } Func <IBindingMetadata, bool> canResolve = null; if (name != null) { canResolve = metadata => metadata.Name == name; } IRequest req = _kernel.CreateRequest(service, canResolve, Empty.Array <IParameter>(), false, true); return(_kernel.CanResolve(req, true)); }
public IExpression CreateFile(int id, string text, string name) { IRequest req = Kernel.CreateRequest(typeof(IExpression), null, new IParameter[] { new Parameter("id", id, false), new Parameter("text", text, false), new Parameter("name", name, false) }, false, false); // I don't know if I've missed the point here or not, but I anticipated that each time i called Bind<> I'd get a different instance // of the class put in the kernel with those passed in parameter values. However I don't I get the same class back each time // with the same values, so the only way to create a new instance is to Unbind<> the original instance and add another with the // new params? if (!this.Kernel.CanResolve(req)) { Kernel.Bind <IExpression>().To <OxTailHelpers.Expression>().InTransientScope() .WithConstructorArgument("id", id) .WithConstructorArgument("text", text) .WithConstructorArgument("name", name); } IExpression expr = this.Kernel.Get <IExpression>(); Kernel.Unbind <IExpression>(); return(expr); }
public TValue TryGet <TValue>(string name = null) where TValue : class { var request = _kernel.CreateRequest(typeof(TValue), b => b.Name == name, new IParameter[0], true, true); return(_kernel.Resolve(request).Cast <TValue>().FirstOrDefault()); }
public static bool IsRegistered(this IKernel kernel, Type type) { return(kernel.CanResolve(kernel.CreateRequest(type, _ => true, new IParameter[] { }, false, false))); }
public object GetService(Type serviceType) { var request = _kernel.CreateRequest(serviceType, null, new Parameter[0], true, true); return(_kernel.Resolve(request).SingleOrDefault()); }
public object Get(Type type, bool optional) { var request = Kernel.CreateRequest(type, null, new IParameter[0], optional, true); return(Kernel.Resolve(request).SingleOrDefault()); }
/// <summary> /// Basic method to find out if the service, <paramref name="serviceType"/>, has been registered with the <param name="kernel"/> /// </summary> /// <param name="kernel"></param> /// <param name="serviceType"></param> /// <returns></returns> public static bool IsRegistered(this IKernel kernel, Type serviceType) { return(kernel.CanResolve(kernel.CreateRequest(serviceType, meta => true, new List <IParameter>(), false, false))); }
/// <summary> /// Determines whether the specified component type has a component. /// </summary> /// <param name="componentType"> /// Type of the component. /// </param> /// <returns> /// <c>true</c> if the specified component type has a component; otherwise, <c>false</c>. /// </returns> public bool HasComponent(Type componentType) { var request = kernel.CreateRequest(componentType, null, new IParameter[0], false, true); return(kernel.CanResolve(request)); }
/// <summary> /// Return true if the given type is registered with the container. /// </summary> /// <param name="type"></param> /// <returns></returns> public override bool IsRegistered(Type type) { return(container.CanResolve(container.CreateRequest(type, null, new List <IParameter>(), false, false))); }
/// <summary> /// Determines whether the specified service type is bindable. /// </summary> /// <param name="serviceType">The type of the service.</param> /// <param name="kernel">The kernel.</param> /// <returns> /// <see langword="true"/> if the specified service type is bindable; otherwise, <see langword="false"/>. /// </returns> public static bool IsBindable(this Type serviceType, IKernel kernel) { var request = kernel.CreateRequest(serviceType, null, new IParameter[] { }, false); return kernel.CanResolve(request); }
/// <summary> /// Determines whether the specified service type is bindable. /// </summary> /// <param name="serviceType">The type of the service.</param> /// <param name="kernel">The kernel.</param> /// <returns> /// <see langword="true"/> if the specified service type is bindable; otherwise, <see langword="false"/>. /// </returns> public static bool IsBindable(this Type serviceType, IKernel kernel) { var request = kernel.CreateRequest(serviceType, null, new IParameter[] { }, false, false); return(kernel.CanResolve(request)); }