/// <summary>
/// Registers the specified type.
/// </summary>
/// <param name="type">The specified type.</param>
/// <param name="registry">The registry.</param>
public void Process(Type type, Registry registry)
{
if (type.IsAbstract || !type.IsClass || !type.Name.EndsWith("Repository"))
{
return;
}
Type interfaceType;
try
{
interfaceType = RepositoryInterfaces.Single(p => p.Name == "I" + type.Name);
}
catch (ArgumentNullException)
{
interfaceType = null;
}
catch (InvalidOperationException)
{
interfaceType = null;
}
if (interfaceType == null)
{
// todo log
throw new Exception("Could not find the corresponding interface for Repository:" + type.Name);
}
registry.AddType(interfaceType, type);
}
public void Process(Type type, Registry registry)
{
if (type.ImplementsInterface<ILatticeGroup>() && !type.IsAbstract && type.IsPublic)
{
registry.AddType(typeof(ILatticeGroup), type, type.FullName);
}
}
public void Process(Type type, Registry registry)
{
if (type.GetInterfaces().Contains(typeof(IModule)))
{
registry.AddType(typeof(IModule), type);
}
}
public void RegisterTypes(Registry registry)
{
foreach (var batchPipelineBehaviourType in _batchPipelineBehaviourTypes)
{
registry.AddType(batchPipelineBehaviourType, batchPipelineBehaviourType);
}
}
public void RegisterTypes(Registry registry)
{
foreach (var messagePipelineBehaviourType in _messagePipelineBehaviourTypes)
{
registry.AddType(messagePipelineBehaviourType, messagePipelineBehaviourType);
}
}
public void Process(Type type, Registry registry)
{
if (PluggableAttribute.MarkedAsPluggable(type))
{
registry.AddType(type);
}
}
public void Process(Type type, Registry registry)
{
if (PluggableAttribute.MarkedAsPluggable(type))
{
registry.AddType(type);
}
}
public void Process(Type type, Registry registry)
{
var validatorTypes = type.FindInterfacesThatClose(typeof(IValidator<>));
foreach(var validatorType in validatorTypes)
registry.AddType(validatorType, type);
}
public void Process(Type type, Registry registry)
{
if (!type.IsAbstract && typeof(ICommandEvent).IsAssignableFrom(type))
{
registry.AddType(typeof(ICommand), typeof(EventCommand<>).MakeGenericType(type), type.Name);
}
}
public void Process(Type type, Registry registry)
{
if (!type.IsAbstract && typeof(IController).IsAssignableFrom(type))
{
registry.AddType(type, type);
}
}
public void Process(Type type, Registry registry)
{
var interceptorTypes = type.FindInterfacesThatClose(typeof(IInterceptor<>));
foreach(var interceptorType in interceptorTypes)
registry.AddType(interceptorType, type);
}
public void Process(Type type, Registry registry)
{
if (type.IsClosedTypeOf(openGenericInterfaceCollectionType))
{
registry.AddType(openGenericInterfaceCollectionType, type);
}
}
public void Process(Type type, Registry registry)
{
if (!type.IsAbstract && typeof(IController).IsAssignableFrom(type))
{
registry.AddType(type, type);
}
}
public void Process(Type type, Registry registry)
{
if (IsConcreteClass(type))
{
registry.AddType(type, type);
}
}
public void Process(Type type, Registry registry)
{
if (type.Assembly == _thisAssembly)
{
return;
}
if (type.CanBeCastTo(typeof(IFixture)))
{
registry.AddType(typeof(IFixture), type, type.GetFixtureAlias());
}
if (type.IsConcreteAndAssignableTo(typeof(IStartupAction)))
{
registry.AddType(typeof(IStartupAction), type, type.Name.Replace("Action", string.Empty));
}
}
public EventsModule()
{
Registry.AddType(typeof(IEventer <>), typeof(EventSink <>));
Registry
.AddType <IEventSystem, EventSystem>()
.WithAlias <IPipeFactory>();
}
public void Process(Type type, Registry registry)
{
if (!type.CanBeCastTo(typeof(IStatusCodeTranslator))) return;
var name = type.Name.Replace("StatusCodeTranslator", "");
registry.AddType(typeof (IStatusCodeTranslator), type, name);
}
public void Process(Type type, Registry registry)
{
Type interfaceType = type.FindFirstInterfaceThatCloses(_openGenericType);
if (interfaceType != null)
{
registry.AddType(interfaceType, type);
}
}
public void ScanTypes(TypeSet types, Registry registry)
{
types.FindTypes(TypeClassification.Concretes).Where(Matches).Each(type =>
{
var name = _getName(type);
registry.AddType(GetLeastSpecificButValidType(_pluginType, type), type, name);
});
}
public void ScanTypes(TypeSet types, Registry registry)
{
types.FindTypes(TypeClassification.Concretes).Where(Matches).Each(type =>
{
var name = _getName(type);
registry.AddType(GetLeastSpecificButValidType(_pluginType, type), type, name);
});
}
public LocalModule()
{
Include <ComplexModule>();
Registry.Instance(new LocalService());
Registry.AddType <ILocalService, LocalService>();
}
public ComplexModule()
{
Include <SimpleModule>();
Registry.Instance(new OtherService());
Registry.AddType <IOtherService, OtherService>();
}
public void Process(Type type, Registry registry)
{
if (type.CanBeCastTo(_pluginType) && Constructor.HasConstructors(type))
{
string name = _getName(type);
registry.AddType(GetLeastSpecificButValidType(_pluginType, type), type, name);
}
}
public void Process(Type type, Registry registry)
{
if (!type.CanBeCastTo(typeof(IResponseWriter))) return;
var name = type.Name.Replace("ResponseWriter", "");
registry.AddType(typeof (IResponseWriter), type, name);
}
public void Process(Type type, Registry registry)
{
if (type.CanBeCastTo(_pluginType) && Constructor.HasConstructors(type))
{
string name = _getName(type);
registry.AddType(GetLeastSpecificButValidType(_pluginType, type), type, name);
}
}
public void Process(Type type, Registry registry)
{
Type interfaceType = type.FindFirstInterfaceThatCloses(_openGenericType);
if (interfaceType != null)
{
registry.AddType(interfaceType, type);
}
}
public void ProcessFacade(Type type, Registry registry, Type facadeInterface, Type genericFacadeInterface, Type concreteFacade)
{
if (type.ImplementsInterfaceTemplate(genericFacadeInterface))
{
var interfaceType = type.FindFirstInterfaceThatCloses(genericFacadeInterface);
var commandMessageTypes = interfaceType.GetGenericArguments();
var closesQuerryProcessor =
concreteFacade.MakeGenericType(commandMessageTypes);
registry.AddType(closesQuerryProcessor);
registry.AddType(interfaceType, type);
}
if (facadeInterface.IsAssignableFrom(type) && !type.IsInterface)
{
registry.AddType(facadeInterface, type);
}
}
public void Process(Type type, Registry registry)
{
bool hasInjectAttribute = type.GetCustomAttributes(false)
.Any(attr => attr.Equals(typeof(InjectAttribute)));
if (hasInjectAttribute)
{
registry.AddType(type);
}
}
public void ProcessFacade(Type type, Registry registry, Type facadeInterface, Type genericFacadeInterface, Type concreteFacade)
{
if (type.ImplementsInterfaceTemplate(genericFacadeInterface))
{
var interfaceType = type.FindFirstInterfaceThatCloses(genericFacadeInterface);
var commandMessageTypes = interfaceType.GetGenericArguments();
var closesQuerryProcessor =
concreteFacade.MakeGenericType(commandMessageTypes);
registry.AddType(closesQuerryProcessor);
registry.AddType(interfaceType, type);
}
if (facadeInterface.IsAssignableFrom(type) && !type.IsInterface)
{
registry.AddType(facadeInterface, type);
}
}
public void Process(Type type, Registry registry)
{
if (!type.CanBeCastTo(typeof (IController)))
return;
string name = GetName(type);
registry.AddType(typeof (IController), type, name);
}
public void Process(Type type, Registry registry)
{
if (type.IsAbstract || !type.IsClass || !typeof(ICommand).IsAssignableFrom(type))
{
return;
}
registry.AddType(typeof(ICommand), type, type.Name);
}
/// <summary>
/// Processes types from an assembly for controllers and implements controller overriding behavior
/// </summary>
/// <param name="type">Type to process</param>
/// <param name="registry">Registry on which to register controllers</param>
public void Process(Type type, Registry registry)
{
// ensure the type is not null, registry isn't null and the type is a valid controller
if (registry == null || !IsValidController(type))
return;
var baseClass = type.BaseType;
// type must inherit from controller with same type name to be overriden.
// The type should be added as normal
// NOTE: this can be extended to be resolved by attribute or something of the sort
if (!IsValidController(baseClass) || !baseClass.Name.Equals(type.Name))
registry.AddType(typeof(IController), type);
else
{
registry.AddType(typeof(IController), baseClass);
registry.RegisterInterceptor(new TypeReplacementInterceptor(baseClass, type));
}
}
/// <inheritdoc />
public void Process(Type type, Registry registry)
{
Type interfaceType = type.GetInterface(typeof(IFoo).Name);
if (interfaceType == null)
{
return;
}
registry.AddType(interfaceType, type, type.Name);
// Do your stuff with INewFoo
}
/// <summary>
/// Processes types from an assembly for controllers and implements controller overriding behavior
/// </summary>
/// <param name="type">Type to process</param>
/// <param name="registry">Registry on which to register controllers</param>
public void Process(Type type, Registry registry)
{
// ensure the type is not null, registry isn't null and the type is a valid controller
if (registry == null || !IsValidController(type))
return;
var baseClass = type.BaseType;
// type must inherit from controller with same type name to be overriden.
// The type should be added as normal
// NOTE: this can be extended to be resolved by attribute or something of the sort
if (!IsValidController(baseClass) || !baseClass.Name.Equals(type.Name))
registry.AddType(typeof(IController), type);
else
{
registry.AddType(typeof(IController), baseClass);
registry.RegisterInterceptor(new TypeReplacementInterceptor(baseClass, type));
}
}
public void Process(Type type, Registry registry)
{
if (!type.IsConcrete()) return;
var baseType = type.BaseType;
if (baseType != null && baseType.IsGenericType && baseType.GetGenericTypeDefinition() == m_mapType)
{
registry.AddType(baseType, type);
}
}
public void Process(Type type, Registry registry)
{
if (type.GetInterfaces().Contains(typeof(IDeviceStrategy)))
{
registry.AddType(typeof(IDeviceStrategy), type);
foreach (Attribute attr in Attribute.GetCustomAttributes(type))
if (attr is OsDeviceAttribute)
Common.DeviceStrategy.Add(((OsDeviceAttribute)attr).Name, type);
}
}
public void Process(Type type, Registry registry)
{
if (type.GetTypeInfo().IsAbstract) return;
if (type.GetTypeInfo().IsInterface) return;
if (type.CanBeCastTo(_pluginType) && type.HasConstructors())
{
var name = _getName(type);
registry.AddType(GetLeastSpecificButValidType(_pluginType, type), type, name);
}
}
public override void Process(Type type, Registry registry)
{
if (!type.IsConcrete()) return;
var pluginType = FindPluginType(type);
if (pluginType != null && type.HasConstructors())
{
registry.AddType(pluginType, type);
ConfigureFamily(registry.For(pluginType));
}
}
public override void Process(Type type, Registry registry)
{
if (!type.IsConcrete() || !type.CanBeCreated()) return;
Type interfaceType = type.AllInterfaces().FirstOrDefault();
if (interfaceType != null)
{
registry.AddType(interfaceType, type);
ConfigureFamily(registry.For(interfaceType));
}
}
public void Process(Type type, Registry registry)
{
if (IsNotRegisterable(type))
{
return;
}
var interfaceType = type.GetInterface(type.Name.Replace("Implementation", string.Empty));
registry.AddType(interfaceType, type);
}
public override void Process(Type type, Registry registry)
{
if (!type.IsConcrete() || !type.CanBeCreated()) return;
Type interfaceType = type.AllInterfaces().FirstOrDefault();
if (interfaceType != null)
{
Debug.WriteLine("Plugging {0} into {1}".ToFormat(type.Name, interfaceType.Name));
registry.AddType(interfaceType, type);
ConfigureFamily(registry.For(interfaceType));
}
}
public override void ScanTypes(TypeSet types, Registry registry)
{
types.FindTypes(TypeClassification.Concretes).Where(type => type.HasConstructors()).Each(type =>
{
var pluginType = FindPluginType(type);
if (pluginType != null)
{
registry.AddType(pluginType, type);
ConfigureFamily(registry.For(pluginType));
}
});
}
public void Process(Type type, Registry registry)
{
var m = _lastPascalWord.Match(type.Name);
if (!type.IsAbstract && !type.IsInterface && type.IsPublic && m.Success)
{
var interfaceType = type.GetInterfaces().FirstOrDefault(iface => iface.Name.EndsWith(m.Value));
if (null != interfaceType)
{
registry.AddType(interfaceType, type, type.Name);
}
}
}
public void Process(Type type, Registry registry)
{
if (type.Assembly == _thisAssembly)
{
return;
}
if (type.CanBeCastTo(typeof(IFixture)))
{
registry.AddType(typeof(IFixture), type, type.GetFixtureAlias());
}
}
public override void ScanTypes(TypeSet types, Registry registry)
{
types.FindTypes(TypeClassification.Concretes).Where(type => type.HasConstructors()).Each(type =>
{
var pluginType = FindPluginType(type);
if (pluginType != null)
{
registry.AddType(pluginType, type);
ConfigureFamily(registry.For(pluginType));
}
});
}
public override void ScanTypes(TypeSet types, Registry registry)
{
types.FindTypes(TypeClassification.Concretes).Where(x => x.HasConstructors()).Each(type =>
{
var interfaceType = type.AllInterfaces().FirstOrDefault();
if (interfaceType != null)
{
registry.AddType(interfaceType, type);
ConfigureFamily(registry.For(interfaceType));
}
});
}
public override void ScanTypes(TypeSet types, Registry registry)
{
types.FindTypes(TypeClassification.Concretes).Where(x => x.HasConstructors()).Each(type =>
{
var interfaceType = type.AllInterfaces().FirstOrDefault();
if (interfaceType != null)
{
registry.AddType(interfaceType, type);
ConfigureFamily(registry.For(interfaceType));
}
});
}
private static void ProcessInterfaceName(Type type, Registry registry, string interfaceName)
{
//Trace.WriteLine(string.Format("RepositoryIntConvention: testing type: {0}, formatted: {1}"
// , type.Name, interfaceName));
// Get interface and register (can use AddType overload method to create named types
Type interfaceType = type.GetInterface(interfaceName);
if (null != interfaceType)
{
Trace.WriteLine("RepositoryIntConvention: adding type: " + type.Name);
registry.AddType(interfaceType, type);
}
}
public void Process(Type type, Registry registry)
{
if (!type.IsConcrete())
{
return;
}
var baseType = type.BaseType;
if (baseType != null && baseType.IsGenericType && baseType.GetGenericTypeDefinition() == m_mapType)
{
registry.AddType(baseType, type);
}
}
public override void ScanTypes(TypeSet types, Registry registry)
{
var interfaces = types.FindTypes(TypeClassification.Interfaces);
var concretes = types.FindTypes(TypeClassification.Concretes).Where(x => x.HasConstructors()).ToArray();
interfaces.Each(@interface =>
{
var implementors = concretes.Where(x => x.CanBeCastTo(@interface)).ToArray();
if (implementors.Count() == 1)
{
registry.AddType(@interface, implementors.Single());
ConfigureFamily(registry.For(@interface));
}
});
}
/// <summary>
/// Processa mapeamento
/// </summary>
/// <param name="type">Tipo sendo mapeado</param>
/// <param name="registry">Grafo de objetos do assembly 'scaneado'</param>
public void Process(Type type, Registry registry)
{
if (type.IsAbstract)
{
return;
}
var interfaceName = this.GetInterfaceName(type);
var interfaceType = type.GetInterface(interfaceName);
if (interfaceType != null)
{
registry.AddType(interfaceType, type);
}
}
public override void ScanTypes(TypeSet types, Registry registry)
{
var interfaces = types.FindTypes(TypeClassification.Interfaces);
var concretes = types.FindTypes(TypeClassification.Concretes).Where(x => x.HasConstructors()).ToArray();
interfaces.Each(@interface =>
{
var implementors = concretes.Where(x => x.CanBeCastTo(@interface)).ToArray();
if (implementors.Count() == 1)
{
registry.AddType(@interface, implementors.Single());
ConfigureFamily(registry.For(@interface));
}
});
}
public void Process(Type type, Registry registry)
{
if (!type.IsConcrete())
{
return;
}
foreach (var @interface in type.GetInterfaces())
{
if (@interface.IsGenericType && @interface.GetGenericTypeDefinition() == _openIHandlesType)
{
registry.AddType(@interface, type);
}
}
}
public override void Process(Type type, Registry registry)
{
if (!type.IsConcrete())
{
return;
}
Type pluginType = FindPluginType(type);
if (pluginType != null && Constructor.HasConstructors(type))
{
registry.AddType(pluginType, type);
ConfigureFamily(registry.For(pluginType));
}
}
public override void Process(Type type, Registry registry)
{
if (!TypeExtensions.IsConcrete(type))
{
return;
}
Type pluginType = this.FindPluginType(type);
if (pluginType == null || !TypeExtensions.HasConstructors(type))
{
return;
}
registry.AddType(pluginType, type);
this.ConfigureFamily(registry.For(pluginType, (ILifecycle)null));
}
public void Process(Type type, Registry registry)
{
if (!type.IsConcreteAndAssignableTo(typeof(IReportGenerator)))
{
return;
}
if (!type.Name.EndsWith("ReportGenerator"))
{
return;
}
var generatorName = type.Name.Remove(type.Name.IndexOf("ReportGenerator"));
registry.AddType(typeof(IReportGenerator), type, generatorName);
}
public void ProcessHandler(Type type, Registry registry, Type typeInterface, Type handlerInterface, Type concreteHandler)
{
if (type.ImplementsInterfaceTemplate(typeInterface))
{
Type interfaceType = type.FindFirstInterfaceThatCloses(typeInterface);
Type[] genericArguments = interfaceType.GetGenericArguments();
Type closeActionProcessprInterface =
handlerInterface.MakeGenericType(genericArguments);
Type closesActionProcessor =
concreteHandler.MakeGenericType(genericArguments);
registry.For(closeActionProcessprInterface).Use(closesActionProcessor);
registry.AddType(interfaceType, type);
}
}
public void Process(Type type, Registry registry)
{
if (type.IsAbstract)
{
return;
}
if (type.IsInterface)
{
return;
}
if (type.CanBeCastTo(_pluginType) && type.HasConstructors())
{
var name = _getName(type);
registry.AddType(GetLeastSpecificButValidType(_pluginType, type), type, name);
}
}
public override void Process(Type type, Registry registry)
{
if (!type.IsConcrete() || !type.CanBeCreated())
{
return;
}
var interfaceType = type.AllInterfaces().FirstOrDefault();
if (interfaceType != null)
{
Debug.WriteLine("Plugging {0} into {1}".ToFormat(type.Name, interfaceType.Name));
registry.AddType(interfaceType, type);
ConfigureFamily(registry.For(interfaceType));
}
}
public override void Process(Type type, Registry registry)
{
if (!type.IsConcrete())
{
return;
}
var pluginType = this.FindPluginType(type);
if (pluginType == null || !type.HasConstructors())
{
return;
}
registry.AddType(pluginType, type);
var policy = CreatePolicy(pluginType);
registry.Policies.Interceptors(policy);
ConfigureFamily(registry.For(pluginType));
}