public bool IsRegistered(Type t)
{
lock (_syncLock)
{
return(_kernel.CanResolve(t) != null);
}
}
public void MultipleConditionalBindingTest()
{
container.AutoBinding(Profiles.PROFILE_D);
Assert.IsTrue(container.CanResolve <Master>());
Assert.IsTrue(container.CanResolve <IMaster2>());
Assert.IsFalse(container.CanResolve <IMaster>());
}
public T GetService <T>()
{
if (sourceKernel.CanResolve <T>())
{
return(sourceKernel.Get <T>());
}
return(default(T));
}
public TService GetInstance <TService>() where TService : class
{
if (!_kernel.CanResolve <TService>())
{
_kernel.Bind <TService>().ToSelf();
}
return(_kernel.Get <TService>());
}
public IServiceRegister Register <TService>(Func <IServiceProvider, TService> serviceCreator) where TService : class
{
// EasyNetQ first adds the overrides, then the defaults, which would then set the default again.
if (!_ninjectContainer.CanResolve <TService>())
{
_ninjectContainer.Bind <TService>().ToMethod(ctx => serviceCreator(this)).InSingletonScope();
}
return(this);
}
private static void BindClass(Type targetType, IKernel kernel)
{
var binding = targetType.GetCustomAttribute <BindToAttribute>();
foreach (var interfaceType in binding.InterfaceTypes)
{
if (kernel.CanResolve(interfaceType))
{
continue;
}
switch (binding.Scope)
{
case Scope.Transient:
kernel.Bind(interfaceType).To(targetType).InTransientScope();
break;
case Scope.Thread:
kernel.Bind(interfaceType).To(targetType).InThreadScope();
break;
case Scope.Singleton:
kernel.Bind(interfaceType).To(targetType).InSingletonScope();
break;
case Scope.Undefined:
default:
throw new NotSupportedException("Defined Scope is not supported");
}
}
}
internal static bool IsHttpEndpoint(Type controllerType)
{
if (controllerType == null)
{
throw new ArgumentNullException("controllerType");
}
var isController = controllerType != null &&
controllerType.IsClass &&
controllerType.IsVisible &&
controllerType.IsAbstract == false &&
typeof(IHttpController).IsAssignableFrom(controllerType);
if (!isController)
{
return(false);
}
var dependancies = controllerType
.GetCustomAttributes(typeof(ControllerDependsOnAttribute), true)
.Cast <ControllerDependsOnAttribute>()
.SelectMany(a => a.Types);
var isEnabled = !dependancies.Any() || dependancies.All(t => _kernel.CanResolve(t));
return(isEnabled);
}
/// <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));
}
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);
}
public void Warmup()
{
// We cannot use Orleans to obtain grains (to warm them up); Orleans only provides lazy grain references, and we'd
// have to call a method on the grain to activate it, but there's no generic method we could call. So we instantiate
// grains through Ninject instead of Orleans to register their dependencies in Ninject. When Orleans will instantiate
// these grains, their non-transient dependencies will already be registered in Ninject, saving startup time.
try
{
List <string> failedWarmupWarn = new List <string>();
foreach (Type serviceClass in _orleansMapper.ServiceClassesTypes)
{
try
{
foreach (Type parameterType in serviceClass.GetConstructors()
.SelectMany(ctor => ctor.GetParameters().Select(p => p.ParameterType)).Distinct())
{
try
{
if (!_kernel.CanResolve(parameterType))
{
if (_orleansInternalTypes.Contains(parameterType) || _orleansInternalTypesString.Any(x => parameterType.FullName.Contains(x)))
{
//No waring on Orleans type
continue;
}
failedWarmupWarn.Add($"Type {parameterType} of grain {serviceClass}");
continue;
}
// Try to warm up dependency
_kernel.Get(parameterType);
}
catch//No exception handling needed. We try to warmup all constructor types. In case of failure, write the warning for non orleans types and go to the next type
{
failedWarmupWarn.Add($"Type {parameterType} of grain {serviceClass}");
}
}
}
catch (Exception e)
{
_log.Warn($"Failed to warmup grain {serviceClass}", e);
}
}
if (failedWarmupWarn.Count > 0)
{
_log.Warn($"Fail to warmup the following types:\n{string.Join("\n", failedWarmupWarn)}");
}
}
catch (Exception ex)
{
_log.Warn("Failed to warmup grains", ex);
}
}
protected override JsonObjectContract CreateObjectContract(Type objectType)
{
var contract = base.CreateObjectContract(objectType);
if ((bool)_kernel.CanResolve(objectType))
{
contract.DefaultCreator = () => _kernel.Get(objectType);
}
return(contract);
}
public static IKernel RegisterPopupNavigationService <TService>(this IKernel kernel)
where TService : PopupPageNavigationService
{
if (!kernel.CanResolve <IPopupNavigation>())
{
kernel.Bind <IPopupNavigation>().ToConstant(PopupNavigation.Instance).InSingletonScope();
}
kernel.Bind <INavigationService>().To <TService>().Named(_navigationServiceName);
return(kernel);
}
/// <summary>
/// Determines whether the specified request can be resolved.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>
/// <c>True</c> if the request can be resolved; otherwise, <c>false</c>.
/// </returns>
public override bool CanResolve(IRequest request)
{
var canResolve = base.CanResolve(request);
if (!canResolve && _parent != null)
{
return(_parent.CanResolve(request));
}
return(canResolve);
}
public void Warmup()
{
// We cannot use Orleans to obtain grains (to warm them up); Orleans only provides lazy grain references, and we'd
// have to call a method on the grain to activate it, but there's no generic method we could call. So we instantiate
// grains through Ninject instead of Orleans to register their dependencies in Ninject. When Orleans will instantiate
// these grains, their non-transient dependencies will already be registered in Ninject, saving startup time.
try
{
List <string> failedWarmupWarn = new List <string>();
List <string> failedWarmupInfo = new List <string>();
foreach (Type serviceClass in _orleansMapper.ServiceClassesTypes)
{
try
{
foreach (Type parameterType in serviceClass.GetConstructors().SelectMany(ctor => ctor.GetParameters().Select(p => p.ParameterType)).Distinct())
{
if (_kernel.CanResolve(parameterType))
{
_kernel.Get(parameterType);
continue;
}
if (_orleansInternalTypes.Contains(parameterType))
{
failedWarmupInfo.Add($"Type {parameterType} of grain {serviceClass}");
}
else
{
failedWarmupWarn.Add($"Type {parameterType} of grain {serviceClass}");
}
}
}
catch (Exception e)
{
_log.Warn($"Failed to warmup grain {serviceClass}", e);
}
}
if (failedWarmupInfo.Count > 0)
{
_log.Info(l => l($"Can't warmup the following types:\n{string.Join("\n", failedWarmupInfo)}"));
}
if (failedWarmupWarn.Count > 0)
{
_log.Warn($"Fail to warmup the following types:\n{string.Join("\n", failedWarmupWarn)}");
}
}
catch (Exception ex)
{
_log.Warn("Failed to warmup grains", ex);
}
}
/// <inheritdoc />
public bool Remove(ServiceDescriptor item)
{
if (item is null)
{
throw new ArgumentNullException(nameof(item));
}
if (_kernel.CanResolve(item.ServiceType))
{
_kernel.Unbind(item.ServiceType);
}
return(_bindingByModuleName[DirectRegister].Remove(item));
}
/// <summary>
///
/// </summary>
/// <param name="kernel"></param>
/// <param name="binding"></param>
/// <returns></returns>
private ConstructorMetadata FindBestConstructor(IKernel kernel, IBinding binding)
{
if (metadata.TargetConstructors.Length == 0)
{
throw new InvalidOperationException(
String.Format(CultureInfo.InvariantCulture, "No constructor avaiable. type = {0}", TargetType.Name));
}
for (var i = 0; i < metadata.TargetConstructors.Length; i++)
{
var match = true;
var cm = metadata.TargetConstructors[i];
var parameters = cm.Parameters;
for (var j = 0; j < parameters.Length; j++)
{
var parameter = parameters[j];
var pi = parameter.Parameter;
// Constructor argument
if (binding.ConstructorArguments.GetParameter(pi.Name) != null)
{
continue;
}
// Multiple
if (parameter.ElementType != null)
{
continue;
}
// Resolve
if (kernel.CanResolve(pi.ParameterType, cm.Constraints[j]))
{
continue;
}
match = false;
break;
}
if (match)
{
return(cm);
}
}
throw new InvalidOperationException(
String.Format(CultureInfo.InvariantCulture, "Constructor parameter unresolved. type = {0}", TargetType.Name));
}
/// <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));
}
/// <summary>
/// Stores the bus instance
/// </summary>
public void SetBus(IBus bus)
{
if (_kernel.CanResolve(typeof(IBus)))
{
throw new InvalidOperationException("Cannot register IBus because it has already been registered. If you want to host multiple Rebus instances in a single process, please use separate container instances for them.");
}
_kernel.Bind <IBus>().ToConstant(bus);
_kernel.Bind <ISyncBus>().ToMethod(c => bus.Advanced.SyncBus);
_kernel.Bind <IMessageContext>().ToMethod(c =>
{
var currentMessageContext = MessageContext.Current;
if (currentMessageContext == null)
{
throw new InvalidOperationException(
"Attempted to inject the current message context from MessageContext.Current, but it was null! Did you attempt to resolve IMessageContext from outside of a Rebus message handler?");
}
return(currentMessageContext);
});
ResolutionExtensions.Get <IBus>(_kernel);
}
/// <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));
}
public static T TryResolve <T>()
{
return(kernel.CanResolve <T>() ? kernel.Get <T>() : default(T));
}
/// <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)));
}
/// <inheritdoc />
public bool HasRegistration(Type serviceType)
{
return(_kernel.CanResolve(serviceType));
}
/// <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)));
}
public bool CanResolve(Type type)
{
return((bool)_kernel.CanResolve(type));
}
public bool IsRegistered <TService>() => _kernel.CanResolve <TService>();
public static bool IsRegistered(this IKernel kernel, Type type)
{
return(kernel.CanResolve(kernel.CreateRequest(type, _ => true, new IParameter[] { }, false, false)));
}
/// <inheritdoc />
public bool HasRegistration(Type serviceType, string contract = null)
{
return(_kernel.CanResolve(serviceType));
}
/// <summary>
/// Checking if TService can be resolved is a workaround to the issue that Ninject
/// does not allow TService to be registered multiple times such that the behavior
/// of DefaultServiceProvider can be emulated using Ninject.
/// </summary>
/// <typeparam name="TService"></typeparam>
/// <returns></returns>
private bool IsAlreadyRegistered <TService>() where TService : class
{
return(_ninjectContainer.CanResolve <TService>());
}
/// <inheritdoc /> public bool IsRegistered(Type type) => _kernel.CanResolve(type);
/// <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);
}
public bool IsRegistered <T>()
{
return(_kernel.CanResolve <T>());
}
