/// <inheritdoc />
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, Castle.Core.ComponentModel model, DependencyModel dependency)
{
if (dependency.TargetType == null)
{
return false;
}
Type genericArgument = null;
if ((dependency.TargetType.IsGenericType) && (dependency.TargetType.GetGenericTypeDefinition() == typeof(IEnumerable<>)))
{
genericArgument = dependency.TargetType.GetGenericArguments()[0];
}
else
{
dependency.TargetType.GetInterfaces().Any(implemented => (implemented.IsGenericType) && (implemented.GetGenericTypeDefinition() == typeof(IEnumerable<>)) &&
((genericArgument = implemented.GetGenericArguments()[0]) != null));
}
if ((genericArgument == null) || (!_kernel.HasComponent(genericArgument)))
{
return false;
}
return true;
}
public object Resolve(CreationContext context,
ISubDependencyResolver parentResolver,
ComponentModel model,
DependencyModel dependency)
{
return _kernel.ResolveAll(dependency.TargetType.GetElementType(), null);
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model,
DependencyModel dependency)
{
return contextHandlerResolver.Resolve(context, contextHandlerResolver, model,
new DependencyModel(DependencyType.Service, typeof(IBookStore).FullName,
typeof(IBookStore), false));
}
public object Resolve(CreationContext context, ISubDependencyResolver parentResolver, ComponentModel model,
DependencyModel dependency)
{
Type elementType = dependency.TargetType.GetElementType();
Array all = kernel.ResolveAll(elementType, new Hashtable());
return all;
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model,
DependencyModel dependency)
{
return dependency.TargetType == typeof(IBookStore) && contextHandlerResolver.CanResolve(context, contextHandlerResolver, model,
new DependencyModel(typeof(IBookStore).FullName,
typeof(IBookStore), false));
}
public bool CanResolve(CreationContext context, ISubDependencyResolver parentResolver, ComponentModel model,
DependencyModel dependency)
{
return Context.CurrentUser != null &&
dependency.TargetType == typeof (INotifications);
}
public object Resolve(CreationContext context, ISubDependencyResolver parentResolver,
ComponentModel model,
DependencyModel dependency)
{
Type t = dependency.TargetType.GetGenericArguments()[0];
return kernel.ResolveAll(t, null);
}
public object Resolve(
CreationContext context,
ISubDependencyResolver parentResolver,
ComponentModel model,
DependencyModel dependency)
{
MockingStrategy strategy = _relatedRepository.GetStrategyFor(dependency);
if (strategy.Instance != null)
return strategy.Instance;
if (strategy.Mock == MockingStrategyType.Mock)
{
//if a dependencywas already registered in the main controller, go and use it
var registration = this._relatedRepository.Kernel.GetHandler(dependency.TargetType);
object resolvedDependencyObject;
if (registration == null)
{
resolvedDependencyObject = MockRepository.GenerateStub(dependency.TargetType);
}
else
{
resolvedDependencyObject = _relatedRepository.Resolve(dependency.TargetType);
}
_relatedRepository.OnMockCreated(resolvedDependencyObject, dependency.DependencyKey);
return resolvedDependencyObject;
}
if (strategy.Mock == MockingStrategyType.Resolve)
return _relatedRepository.Resolve(dependency.TargetType);
return null;
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
string componentName = null;
if (!_knownDependencies.ContainsKey(dependency))
componentName = dependency.DependencyKey;
return _kernel.Resolve(componentName, dependency.TargetType);
}
public object Resolve(CreationContext context, ISubDependencyResolver parentResolver, ComponentModel model,
DependencyModel dependency)
{
if (dependency.TargetType == typeof (ISession))
return SessionFactory.OpenSession();
return SessionFactory.OpenStatelessSession();
}
/// <summary>
/// Returns true if the resolver is able to satisfy the specified dependency.
/// </summary>
/// <param name = "context">Creation context, which is a resolver itself</param>
/// <param name = "contextHandlerResolver">Parent resolver</param>
/// <param name = "model">Model of the component that is requesting the dependency</param>
/// <param name = "dependency">The dependency model</param>
/// <returns>
/// <c>true</c>
/// if the dependency can be satisfied</returns>
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
// 1 - check for the dependency on CreationContext, if present
if (CanResolveFromContext(context, contextHandlerResolver, model, dependency))
{
return true;
}
// 2 - check with the model's handler, if not the same as the parent resolver
if (CanResolveFromHandler(context, contextHandlerResolver, model, dependency))
{
return true;
}
// 3 - check within parent resolver, if present
if (CanResolveFromContextHandlerResolver(context, contextHandlerResolver, model, dependency))
{
return true;
}
// 4 - check within subresolvers
if (CanResolveFromSubResolvers(context, contextHandlerResolver, model, dependency))
{
return true;
}
// 5 - normal flow, checking against the kernel
return CanResolveFromKernel(context, model, dependency);
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return dependency.TargetType != null &&
dependency.TargetType.IsArray &&
dependency.TargetType.GetElementType().IsInterface &&
!model.Parameters.Contains(dependency.DependencyKey);
}
public bool CanResolve(
CreationContext context,
ISubDependencyResolver parentResolver,
ComponentModel model,
DependencyModel dependency )
{
return dependency.DependencyType == DependencyType.Service;
}
public override object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver,
ComponentModel model,
DependencyModel dependency)
{
var items = base.Resolve(context, contextHandlerResolver, model, dependency);
var listType = BuildListType(dependency);
return listType.CreateInstance<object>(items);
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver,
ComponentModel model,
DependencyModel dependency)
{
return dependency.TargetType != null &&
dependency.TargetType.IsArray &&
kernel.HasComponent(dependency.TargetType.GetElementType());
}
public bool CanResolve(CreationContext context, ISubDependencyResolver parentResolver,
ComponentModel model,
DependencyModel dependency)
{
return dependency.TargetType != null &&
dependency.TargetType.IsArray &&
dependency.TargetType.GetElementType().IsInterface;
}
/// <summary>
/// Returns true if the resolver is able to satisfy the specified dependency.
/// </summary>
/// <param name="context">Creation context, which is a resolver itself</param>
/// <param name="contextHandlerResolver">Parent resolver</param>
/// <param name="model">Model of the component that is requesting the dependency</param>
/// <param name="dependency">The dependency model</param>
/// <returns><c>true</c> if the dependency can be satisfied</returns>
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model,
DependencyModel dependency)
{
// 1 - check for the dependency on CreationContext, if present
if (context != null)
{
if (context.CanResolve(context, contextHandlerResolver, model, dependency))
{
return true;
}
}
// 2 - check with the model's handler, if not the same as the parent resolver
IHandler handler = kernel.GetHandler(model.Name);
if (handler != null && handler != contextHandlerResolver)
{
if (handler.CanResolve(context, contextHandlerResolver, model, dependency))
{
return true;
}
}
// 3 - check within parent resolver, if present
if (contextHandlerResolver != null)
{
if (contextHandlerResolver.CanResolve(context, contextHandlerResolver, model, dependency))
{
return true;
}
}
// 4 - check within subresolvers
foreach(ISubDependencyResolver subResolver in subResolvers)
{
if (subResolver.CanResolve(context, contextHandlerResolver, model, dependency))
{
return true;
}
}
// 5 - normal flow, checking against the kernel
if (dependency.DependencyType == DependencyType.Service ||
dependency.DependencyType == DependencyType.ServiceOverride)
{
return CanResolveServiceDependency(context, model, dependency);
}
else
{
return CanResolveParameterDependency(model, dependency);
}
}
/// <summary>
/// Returns true if the resolver is able to satisfy this dependency.
/// </summary>
/// <param name="context">
/// Creation context, which is a resolver itself
/// </param>
/// <param name="contextHandlerResolver">
/// Parent resolver - normally the IHandler implementation
/// </param>
/// <param name="model">
/// Model of the component that is requesting the dependency
/// </param>
/// <param name="dependency">
/// The dependency model
/// </param>
/// <returns>
/// <c>true</c> if the dependency can be satisfied
/// </returns>
public bool CanResolve(
CreationContext context,
ISubDependencyResolver contextHandlerResolver,
ComponentModel model,
DependencyModel dependency)
{
return ConfigurationManager.AppSettings.AllKeys.Contains(dependency.DependencyKey)
&& TypeDescriptor.GetConverter(dependency.TargetType).CanConvertFrom(typeof(string));
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver,
ComponentModel model,
DependencyModel dependency)
{
var targetType = dependency.TargetItemType;
return targetType != null &&
targetType.IsArray &&
(allowEmptyArray || kernel.HasComponent(targetType.GetElementType()));
}
public object Resolve(CreationContext context,
ISubDependencyResolver parentResolver,
ComponentModel model,
DependencyModel dependency)
{
var targetType = dependency.TargetType.GetElementType();
var resolved = _kernel.ResolveAll(targetType, null);
return resolved;
}
/// <summary>
/// Initializes a new instance of the <see cref="ParentHandlerWithChildResolver"/> class.
/// </summary>
/// <param name="parentHandler">The parent handler.</param>
/// <param name="childResolver">The child resolver.</param>
public ParentHandlerWithChildResolver(IHandler parentHandler, ISubDependencyResolver childResolver)
{
if (parentHandler == null) throw new ArgumentNullException("parentHandler");
if (childResolver == null) throw new ArgumentNullException("childResolver");
this.parentHandler = parentHandler;
parentHandler.OnHandlerStateChanged += new HandlerStateDelegate(RaiseHandlerStateChanged);
this.childResolver = childResolver;
}
/// <summary>
/// Unregisters a sub resolver instance previously registered
/// </summary>
/// <param name = "subResolver">The subresolver instance</param>
public void RemoveSubResolver(ISubDependencyResolver subResolver)
{
if (subResolver == null)
{
throw new ArgumentNullException("subResolver");
}
subResolvers.Remove(subResolver);
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver,
ComponentModel model, DependencyModel dependency)
{
var candidateType = GetItemType(dependency.TargetItemType);
var candidates = _kernel.ResolveAll(candidateType);
var typeToConstruct = typeof (Registry<>).GetGenericTypeDefinition().MakeGenericType(new[] {candidateType});
return Activator.CreateInstance(typeToConstruct, candidates);
}
public virtual object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model,
DependencyModel dependency)
{
Array result = kernel.ResolveAll(GetItemType(dependency.TargetItemType), null);
if (_orderFunc != null)
{
Array.Sort(result, new GenericComparer(_orderFunc));
}
return result;
}
public bool CanResolve(CreationContext context,
ISubDependencyResolver parentResolver,
ComponentModel model,
DependencyModel dependency)
{
return dependency.TargetType != null &&
dependency.TargetType.IsArray &&
dependency.TargetType.GetElementType().IsInterface &&
!model.Parameters.Any(x => x.Value == dependency.DependencyKey);
}
public bool CanResolve(CreationContext context, ISubDependencyResolver parentResolver,
ComponentModel model,
DependencyModel dependency)
{
bool result = dependency.TargetType != null &&
dependency.TargetType.GetGenericArguments().Length != 0 &&
typeof(IEnumerable<>)
.MakeGenericType(dependency.TargetType.GetGenericArguments()[0])
.IsAssignableFrom(dependency.TargetType);
return result;
}
public bool CanResolve(CreationContext context, ISubDependencyResolver parentResolver, ComponentModel model, DependencyModel dependency)
{
try
{
return _serviceInterfaceResolver.AttemptResolve(dependency.TargetType, _componentModelSource.Models) != null;
}
catch (Exception error)
{
throw new ServiceResolutionException(String.Format("Error resolving {0}", model.Name), error);
}
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver,
ComponentModel model, DependencyModel dependency)
{
if (dependency.TargetItemType == null) return false;
if (dependency.TargetItemType.IsGenericType &&
dependency.TargetItemType.GetGenericTypeDefinition() != typeof (Registry<>)) return false;
var itemType = GetItemType(dependency.TargetItemType);
return itemType != null && _kernel.HasComponent(itemType);
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
// This person is the 'currently logged-in user', i.e. the context needed to resolve which implementation
// of ISecurityService needs to be returned
Person person = kernel.Resolve<Person>();
if (person.UserName == "richard")
{
return new InsecureSecurityService();
}
return new SecureSecurityService();
}
public object Resolve(
CreationContext context,
ISubDependencyResolver contextHandlerResolver,
ComponentModel model,
DependencyModel dependency)
{
return TypeDescriptor
.GetConverter(dependency.TargetType)
.ConvertFrom(
ConfigurationManager.AppSettings[dependency.DependencyKey]);
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model,
DependencyModel dependency)
{
// We will never actually resolve the component, but always use the standard SubDependencyResolver, as Can resolve always returns false;
return(null);
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return(kernel.Resolve(dependency.TargetType));
}
public object Resolve(Castle.MicroKernel.Context.CreationContext context, ISubDependencyResolver contextHandlerResolver, Castle.Core.ComponentModel model, Castle.Core.DependencyModel dependency)
{
throw new NotImplementedException();
}
public virtual bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver,
ComponentModel model,
DependencyModel dependency)
{
return(HasAdditionalArguments && (CanResolveByKey(dependency) || CanResolveByType(dependency)));
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return(model.ComponentName.Name.EndsWith(AppSettingsInstaller.AppSettingsModelpostfix) &&
DontInjectProperties(dependency) && (dependency.TargetType == typeof(int) ||
dependency.TargetType == typeof(bool) || dependency.TargetType == typeof(string) || dependency.TargetType == typeof(double)));
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
ThrowIfServiceProviderIsNull();
return(serviceProvider.GetService(dependency.TargetType));
}
public object Resolve(CreationContext context, ISubDependencyResolver parentResolver, ComponentModel model,
DependencyModel dependency)
{
return(AutoMock.Get(dependency.TargetType));
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return(dependency.TargetType != null &&
dependency.TargetType.IsArray);
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return(typeof(IEnumerable).IsAssignableFrom(dependency.TargetType) && dependency.TargetType != typeof(string));
}
public virtual object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model,
DependencyModel dependency)
{
return(kernel.ResolveAll(GetItemType(dependency.TargetItemType), context.AdditionalArguments));
}
/// <summary>
/// Check if dependency is of type ILog
/// </summary>
/// <param name="context"></param>
/// <param name="contextHandlerResolver"></param>
/// <param name="model"></param>
/// <param name="dependency"></param>
/// <returns></returns>
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return(dependency.TargetType == typeof(ILog));
}
public bool CanResolve(CreationContext context, ISubDependencyResolver parentResolver, ComponentModel model,
DependencyModel dependency)
{
return(Context.CurrentUser != null &&
dependency.TargetType == typeof(INotifications));
}
public object Resolve(CreationContext context, ISubDependencyResolver parentResolver, ComponentModel model, DependencyModel dependency)
{
throw new NotImplementedException();
}
public object Resolve(CreationContext context, ISubDependencyResolver parentResolver,
ComponentModel model,
DependencyModel dependency)
{
return(kernel.ResolveAll(dependency.TargetType.GetElementType(), null));
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return(dependency.TargetType != null &&
dependency.TargetType.GetTypeInfo().IsGenericType&&
dependency.TargetType.GetGenericTypeDefinition() == typeof(IOptions <>));
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return(container.Resolve <IEnumerable <Priority> >());
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return(this.kernel.Resolve(dependency.DependencyKey, typeof(DirectoryInfo)));
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return(Result.Value);
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return(HasMatchingType(dependency.TargetType));
}
private bool CanResolveFromSubResolvers(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model,
DependencyModel dependency)
{
return(subResolvers.Count > 0 && subResolvers.Any(s => s.CanResolve(context, contextHandlerResolver, model, dependency)));
}
private bool CanResolveFromContextHandlerResolver(CreationContext context, ISubDependencyResolver contextHandlerResolver,
ComponentModel model, DependencyModel dependency)
{
return(contextHandlerResolver != null && contextHandlerResolver.CanResolve(context, contextHandlerResolver, model, dependency));
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
var factory = _kernel.Resolve <ILoggerFactory>();
return(factory.CreateLogger(RegistrationAdapter.OriginalComponentName(model.Name)));
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return(Result != null);
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return(dependency.TargetType != null && GetAttribute(model.Implementation, dependency) != null);
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model,
DependencyModel dependency)
{
return(kernel.Resolve <IBookStore>());
}
public void RemoveSubResolver(ISubDependencyResolver subResolver)
{
throw new NotImplementedException();
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model,
DependencyModel dependency)
{
return(new SatiWatcher());
}
public bool CanResolve(CreationContext context, ISubDependencyResolver parentResolver, ComponentModel model,
DependencyModel dependency)
{
return(dependency.DependencyType == DependencyType.Service &&
AutoMock.CanResolve(dependency.TargetType));
}
/// <summary>
/// Unregisters a sub resolver instance previously registered
/// </summary>
/// <param name = "subResolver">The subresolver instance</param>
public void RemoveSubResolver(ISubDependencyResolver subResolver)
{
subResolvers.Remove(subResolver);
}
public bool CanResolve(CreationContext context, ISubDependencyResolver parentResolver, ComponentModel model, DependencyModel dependency)
{
return(false);
}
