private void AutomaticallySubscribeConsumerMessages()
{
var handlers = kernel.GetAssignableHandlers(typeof(IMessageConsumer));
foreach (var handler in handlers)
{
var msgs = reflection.GetMessagesConsumed(handler.ComponentModel.Implementation,
type => type == typeof(OccasionalConsumerOf <>) ||
type == typeof(Consumer <> .SkipAutomaticSubscription));
foreach (var msg in msgs)
{
Subscribe(msg);
}
}
}
public IHandler[] Inspect()
{
var allHandlers = kernel.GetAssignableHandlers(typeof(object));
var waitingHandlers = allHandlers.FindAll(IsWaitingForDependencies);
return(waitingHandlers);
}
public IHandler[] Inspect()
{
var allHandlers = kernel.GetAssignableHandlers(typeof(object));
var handlersWithContainerDependency = allHandlers.FindAll(HasDependencyOnTheContainer);
return(handlersWithContainerDependency.FindAll(h => ExceptionsToTheRule.Any(e => e(h)) == false));
}
public async Task SubscribeAsync()
{
var subscribeToMessages = new HashSet <Type>();
foreach (var listener in _listeners)
{
foreach (var message in listener.ListeningTo)
{
subscribeToMessages.Add(message);
}
}
//then should scan Castle for each component that registered IHandleMessage
foreach (var handler in _kernel.GetAssignableHandlers(typeof(Object)))
{
var messageHandlers = handler.ComponentModel.Services
.Where(s => s.IsGenericType && s.GetGenericTypeDefinition() == typeof(IHandleMessages <>));
foreach (var handlerType in messageHandlers)
{
subscribeToMessages.Add(handlerType.GenericTypeArguments[0]);
}
}
foreach (var type in subscribeToMessages)
{
// subscription
await _bus.Subscribe(type).ConfigureAwait(false);
}
}
static IList <Type> FindTypes <T>(IKernel container, Func <Type, bool> filter)
{
return(container
.GetAssignableHandlers(typeof(T))
.Select(h => h.ComponentModel.Services.First())
.Where(filter)
.ToList());
}
static IEnumerable <Type> FindStateMachineSagaTypes(IKernel container)
{
List <Type> types = container.GetAssignableHandlers(typeof(StateMachine))
.Where(x => x.HasInterface(typeof(SagaStateMachine <>)))
.Select(x => x.ComponentModel.Implementation)
.Distinct()
.ToList();
return(types);
}
public SammyApplication(IKernel kernel, Assembly[] assembly)
{
_kernel = kernel;
var types = assembly.SelectMany<Assembly, Type>(a => a.GetTypes()).ToArray();
// Should this be off some kind of marker (like HttpApplication)?
_kernel.Register(AllTypes.From(types).BasedOn<SammyController>());
// This is getting a bit large - how do we initialize this better?
Routes = RouteCollector.Collect(_kernel.GetAssignableHandlers(typeof(SammyController)).Select(h => h.Service).ToArray());
}
public IHandler[] Inspect()
{
var allHandlers = kernel.GetAssignableHandlers(typeof(object));
#if SILVERLIGHT
return(allHandlers.Where(IsWaitingForDependencies).ToArray());
#else
var waitingHandlers = Array.FindAll(allHandlers, IsWaitingForDependencies);
return(waitingHandlers);
#endif
}
private static void Verify(IKernel kernel)
{
string[] handlers = (from handler in kernel.GetAssignableHandlers(typeof(object))
where handler.CurrentState == HandlerState.WaitingDependency
select handler.ComponentModel.Name).ToArray();
if (handlers.Length != 0)
{
throw new ComponentRegistrationException("The following types could not be resolved: " + string.Join(", ", handlers));
}
}
public static IEnumerable <IHandler> FindExtensions(IKernel kernel, WcfExtensionScope scope, Type type)
{
foreach (var handler in kernel.GetAssignableHandlers(type))
{
var model = handler.ComponentModel;
var extensionsScope = GetScope(model);
if (ScopesCompatible(scope, extensionsScope))
{
yield return(handler);
}
}
}
public Pair <IHandler, DependencyDuplicate[]>[] Inspect()
{
var allHandlers = kernel.GetAssignableHandlers(typeof(object));
var result = new List <Pair <IHandler, DependencyDuplicate[]> >();
foreach (var handler in allHandlers)
{
var duplicateDependencies = FindDuplicateDependenciesFor(handler);
if (duplicateDependencies.Length > 0)
{
result.Add(new Pair <IHandler, DependencyDuplicate[]>(handler, duplicateDependencies));
}
}
return(result.ToArray());
}
private WindsorModelBinderProvider InstanceModelBinderProvider(IKernel kernel)
{
IDictionary<Type, Type> modelBinderTypes = new Dictionary<Type, Type>();
IHandler[] handlers = kernel.GetAssignableHandlers(typeof(IModelBinder));
foreach (IHandler handler in handlers)
{
Type modelBinderType = handler.ComponentModel.Implementation;
ModelTypeAttribute modelTypeAttribute = modelBinderType.GetAttribute<ModelTypeAttribute>();
if (modelTypeAttribute == null)
{
throw new ArgumentException(Error.ModelTypeAttributeMissing.FormatWith(modelBinderType.FullName));
}
modelBinderTypes.Add(modelTypeAttribute.ModelType, modelBinderType);
}
return new WindsorModelBinderProvider(kernel, modelBinderTypes);
}
public void Subscribe()
{
var subscriber = _bus.GetType().GetMethod("Subscribe");
var subscribeToMessages = new HashSet <Type>();
foreach (var listener in _listeners)
{
var processManagerType = listener.GetProcessType();
foreach (var message in listener.ListeningTo)
{
subscribeToMessages.Add(message);
// adapter
var handlerType = typeof(IHandleMessages <>).MakeGenericType(message);
var handlerImpl = typeof(RebusSagaAdapter <,>).MakeGenericType(processManagerType, message);
_kernel.Register(
Component
.For(handlerType)
.ImplementedBy(handlerImpl)
.LifeStyle.Transient
);
}
}
//then should scan Castle for each component that registered IHandleMessage
foreach (var handler in _kernel.GetAssignableHandlers(typeof(Object)))
{
var messageHandlers = handler.ComponentModel.Services
.Where(s => s.IsGenericType && s.GetGenericTypeDefinition() == typeof(IHandleMessages <>));
foreach (var handlerType in messageHandlers)
{
subscribeToMessages.Add(handlerType.GenericTypeArguments[0]);
}
}
foreach (var type in subscribeToMessages)
{
// subscription
var subscription = subscriber.MakeGenericMethod(new[] { type });
subscription.Invoke(_bus, new object[] { });
}
}
private WindsorModelBinderProvider InstanceModelBinderProvider(IKernel kernel)
{
IDictionary <Type, Type> modelBinderTypes = new Dictionary <Type, Type>();
IHandler[] handlers = kernel.GetAssignableHandlers(typeof(IModelBinder));
foreach (IHandler handler in handlers)
{
Type modelBinderType = handler.ComponentModel.Implementation;
if (modelBinderType.IsAbstract || !modelBinderType.IsClass)
{
continue;
}
ModelTypeAttribute modelTypeAttribute = modelBinderType.GetAttribute <ModelTypeAttribute>();
if (modelTypeAttribute == null)
{
throw new ArgumentException(Resources.Error.ModelTypeAttributeMissing.FormatWith(modelBinderType.FullName));
}
modelBinderTypes.Add(modelTypeAttribute.ModelType, modelBinderType);
}
return(new WindsorModelBinderProvider(kernel, modelBinderTypes));
}
/// <inheritdoc />
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, Castle.Core.ComponentModel model, DependencyModel dependency)
{
Type genericArgument = null;
if ((dependency.TargetType.IsGenericType) && (dependency.TargetType.GetGenericTypeDefinition() == typeof(IEnumerable <>)))
{
genericArgument = dependency.TargetType.GetGenericArguments()[0];
}
else
{
dependency.TargetType.GetInterfaces().First(implemented => (implemented.IsGenericType) && (implemented.GetGenericTypeDefinition() == typeof(IEnumerable <>)) &&
((genericArgument = implemented.GetGenericArguments()[0]) != null));
}
var handlers = _kernel.GetAssignableHandlers(genericArgument).Distinct(HandlerEqualityComparer.Instance);
var components = handlers
.Where(h => h.CurrentState == HandlerState.Valid)
.Select(h => h.Resolve(new CreationContext(genericArgument, context, true)))
.ToArray();
var result = Array.CreateInstance(genericArgument, components.Length);
components.CopyTo(result, 0);
return(result);
}
public IHandler[] Inspect()
{
return(kernel.GetAssignableHandlers(typeof(object)));
}
/// <summary>
/// Resolves component but will throw if any of <typeparamref name="T"/>cannot be resolved
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
private IEnumerable <T> ResolveAssert <T>()
{
var handlers = kernel.GetAssignableHandlers(typeof(T));
return(handlers.Select(h => h.Resolve(CreationContext.Empty)).Cast <T>().ToArray());
}
private IList <Type> RetrieveAllTypeFromWindsor(Type type)
{
return(kernel.GetAssignableHandlers(type)
.Select(x => x.ComponentModel.Implementation)
.ToList());
}
public ILookup <Type, IHandler> Inspect()
{
return(kernel.GetAssignableHandlers(typeof(object))
.SelectMany(handler => handler.ComponentModel.Services, (handler, service) => new { handler, service })
.ToLookup(g => g.service, g => g.handler));
}
