/// <summary>
/// Registers the by I service registration.
/// </summary>
/// <param name="registrar">The registrar.</param>
/// <param name="predicate">The predicate.</param>
/// <param name="assemblies">The assemblies.</param>
public static void RegisterByIServiceRegistration(this IServiceRegistrar registrar, Predicate <Type> predicate, params Assembly[] assemblies)
{
if (registrar == null)
{
throw new ArgumentNullException("registrar");
}
var debugger = ServiceLocatorManager.Debugger;
if (debugger == null || (debugger.Flags & ServiceLocatorManagerDebugger.DebuggerFlags.ByIServiceRegistration) != ServiceLocatorManagerDebugger.DebuggerFlags.ByIServiceRegistration)
{
if (assemblies == null || assemblies.Count() == 0)
{
return;
}
var locator = registrar.Locator;
var registrationType = typeof(IServiceRegistrant);
var matchedTypes = assemblies.SelectMany(a => a.AsConcreteTypes(registrationType, predicate))
.Where(t => !ServiceLocatorManager.HasIgnoreServiceLocator(t));
foreach (var matchedType in matchedTypes)
{
locator.Resolve <IServiceRegistrant>(matchedType).Register(registrar);
}
}
else
{
var log = debugger.Log;
log.Information("RegisterByIServiceRegistration");
if (assemblies == null || assemblies.Count() == 0)
{
log.Information("Done. No assemblies requested.");
return;
}
var locator = registrar.Locator;
var registrationType = typeof(IServiceRegistrant);
var matchedTypes = assemblies.SelectMany(a =>
{
log.InformationFormat("- Scanning assembly {0}:", a.FullName);
return(a.AsConcreteTypes(registrationType, predicate));
})
.Where(t =>
{
if (!ServiceLocatorManager.HasIgnoreServiceLocator(t))
{
return(true);
}
log.InformationFormat("- {0} HasIgnoreServiceLocator and has been skipped.", t.FullName);
return(false);
});
foreach (var matchedType in matchedTypes)
{
log.InformationFormat("- {0} Matching Type.", matchedType.FullName);
locator.Resolve <IServiceRegistrant>(matchedType).Register(registrar);
}
log.Information("Done.");
}
}
/// <summary>
/// Loads from configuration.
/// </summary>
/// <param name="service">The service.</param>
/// <param name="configuration">The configuration.</param>
/// <returns></returns>
public static Lazy <IServiceLocator> LoadFromConfiguration(this Lazy <IServiceLocator> service, ServiceLocatorConfiguration configuration)
{
ServiceLocatorManager.GetSetupDescriptor(service).LoadFromConfiguration(service, configuration); return(service);
}
/// <summary>
/// Registers the by naming convention.
/// </summary>
/// <param name="action">The action.</param>
/// <param name="predicate">The predicate.</param>
/// <param name="assemblies">The assemblies.</param>
public static void RegisterByNamingConvention(Action <Type, Type> action, Predicate <Type> predicate, IEnumerable <Assembly> assemblies)
{
if (action == null)
{
throw new ArgumentNullException("action");
}
var debugger = ServiceLocatorManager.Debugger;
if (debugger == null || (debugger.Flags & ServiceLocatorManagerDebugger.DebuggerFlags.ByNamingConvention) != ServiceLocatorManagerDebugger.DebuggerFlags.ByNamingConvention)
{
if (assemblies == null || assemblies.Count() == 0)
{
return;
}
var interfaceTypes = assemblies.SelectMany(a => a.AsTypes(t => t.IsInterface && t.Name.StartsWith("I") && (predicate == null || predicate(t))));
foreach (var interfaceType in interfaceTypes)
{
var concreteName = interfaceType.Name.Substring(1);
var matchedTypes = interfaceType.Assembly.AsConcreteTypes(interfaceType, predicate)
.Where(t => t.Name == concreteName && !ServiceLocatorManager.HasIgnoreServiceLocator(t))
.ToList();
if (matchedTypes.Count == 1)
{
action(interfaceType, matchedTypes.First());
}
}
}
else
{
var log = debugger.Log;
log.Information("RegisterByNamingConvention");
if (assemblies == null || assemblies.Count() == 0)
{
log.Information("Done. No assemblies requested.");
return;
}
var interfaceTypes = assemblies.SelectMany(a =>
{
log.InformationFormat("- Scanning assembly {0}:", a.FullName);
return(a.AsTypes(t => t.IsInterface && t.Name.StartsWith("I") && (predicate == null || predicate(t))));
});
foreach (var interfaceType in interfaceTypes)
{
var concreteName = interfaceType.Name.Substring(1);
var matchedTypes = interfaceType.Assembly.AsConcreteTypes(interfaceType, predicate)
.Where(t =>
{
if (t.Name == concreteName)
{
if (!ServiceLocatorManager.HasIgnoreServiceLocator(t))
{
return(true);
}
log.InformationFormat("- {0} HasIgnoreServiceLocator and has been skipped.", t.FullName);
return(false);
}
return(true);
})
.ToList();
if (matchedTypes.Count == 1)
{
log.InformationFormat("- {0} matches {1}.", interfaceType.FullName, matchedTypes.First());
action(interfaceType, matchedTypes.First());
}
else
{
log.InformationFormat("- {0} Matched {1} types and has been skipped.", interfaceType.FullName, matchedTypes.Count);
}
}
log.Information("Done.");
}
}
/// <summary>
/// Registers the by type match.
/// </summary>
/// <param name="service">The service.</param>
/// <param name="basedOnType">Type of the based on.</param>
/// <param name="predicate">The predicate.</param>
/// <param name="assemblies">The assemblies.</param>
/// <returns></returns>
public static Lazy <IServiceLocator> RegisterByTypeMatch(this Lazy <IServiceLocator> service, Type basedOnType, Predicate <Type> predicate, params Assembly[] assemblies)
{
ServiceLocatorManager.GetSetupDescriptor(service).Do(l => RegisterByTypeMatch(l.Registrar, basedOnType, predicate, assemblies)); return(service);
}
/// <summary>
/// Registers the by type match.
/// </summary>
/// <typeparam name="TBasedOn">The type of the based on.</typeparam>
/// <param name="service">The service.</param>
/// <param name="assemblies">The assemblies.</param>
/// <returns></returns>
public static Lazy <IServiceLocator> RegisterByTypeMatch <TBasedOn>(this Lazy <IServiceLocator> service, params Assembly[] assemblies)
{
ServiceLocatorManager.GetSetupDescriptor(service).Do(l => RegisterByTypeMatch(l.Registrar, typeof(TBasedOn), null, assemblies)); return(service);
}
/// <summary>
/// Registers the by type match.
/// </summary>
/// <param name="service">The service.</param>
/// <param name="basedOnType">Type of the based on.</param>
/// <param name="predicate">The predicate.</param>
/// <returns></returns>
public static Lazy <IServiceLocator> RegisterByTypeMatch(this Lazy <IServiceLocator> service, Type basedOnType, Predicate <Type> predicate)
{
var assembiles = new[] { GetPreviousCallingMethodAssembly() }; ServiceLocatorManager.GetSetupDescriptor(service).Do(l => RegisterByTypeMatch(l.Registrar, basedOnType, predicate, assembiles)); return(service);
}
/// <summary>
/// Registers the by naming convention.
/// </summary>
/// <param name="service">The service.</param>
/// <param name="predicate">The predicate.</param>
/// <param name="assemblies">The assemblies.</param>
/// <returns></returns>
public static Lazy <IServiceLocator> RegisterByNamingConvention(this Lazy <IServiceLocator> service, Predicate <Type> predicate, params Assembly[] assemblies)
{
ServiceLocatorManager.GetSetupDescriptor(service).Do(l => RegisterByNamingConvention(l.Registrar, predicate, assemblies)); return(service);
}
//
/// <summary>
/// Registers the by type match.
/// </summary>
/// <typeparam name="TBasedOn">The type of the based on.</typeparam>
/// <param name="service">The service.</param>
/// <returns></returns>
public static Lazy <IServiceLocator> RegisterByTypeMatch <TBasedOn>(this Lazy <IServiceLocator> service)
{
var assembiles = new[] { GetPreviousCallingMethodAssembly() }; ServiceLocatorManager.GetSetupDescriptor(service).Do(l => RegisterByTypeMatch(l.Registrar, typeof(TBasedOn), null, assembiles)); return(service);
}
/// <summary>
/// Registers the by I service registration.
/// </summary>
/// <param name="service">The service.</param>
/// <param name="assemblies">The assemblies.</param>
/// <returns></returns>
public static Lazy <IServiceLocator> RegisterByIServiceRegistration(this Lazy <IServiceLocator> service, params Assembly[] assemblies)
{
ServiceLocatorManager.GetSetupDescriptor(service).Do(l => RegisterByIServiceRegistration(l.Registrar, null, assemblies)); return(service);
}
//
/// <summary>
/// Registers the by naming convention.
/// </summary>
/// <param name="service">The service.</param>
/// <returns></returns>
public static Lazy <IServiceLocator> RegisterByNamingConvention(this Lazy <IServiceLocator> service)
{
var assembiles = new[] { GetPreviousCallingMethodAssembly() }; ServiceLocatorManager.GetSetupDescriptor(service).Do(l => RegisterByNamingConvention(l.Registrar, null, assembiles)); return(service);
}
/// <summary>
/// Registers the with service locator.
/// </summary>
/// <param name="service">The service.</param>
/// <param name="locator">The locator.</param>
/// <param name="name">The name.</param>
/// <returns></returns>
public static Lazy <IServiceLocator> RegisterWithServiceLocator(this Lazy <IServiceLocator> service, IServiceLocator locator, string name)
{
ServiceLocatorManager.GetSetupDescriptor(service).RegisterWithServiceLocator(service, locator, name); return(service);
}
/// <summary>
/// Registers the with service locator.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="service">The service.</param>
/// <param name="locator">The locator.</param>
/// <returns></returns>
public static Lazy <IServiceLocator> RegisterWithServiceLocator <T>(this Lazy <IServiceLocator> service, IServiceLocator locator)
where T : class, IServiceLocator
{
ServiceLocatorManager.GetSetupDescriptor(service).RegisterWithServiceLocator <T>(service, locator, null); return(service);
}
/// <summary>
/// Registers the with service locator.
/// </summary>
/// <param name="service">The service.</param>
/// <param name="locator">The locator.</param>
/// <returns></returns>
public static Lazy <IServiceLocator> RegisterWithServiceLocator(this Lazy <IServiceLocator> service, Lazy <IServiceLocator> locator)
{
ServiceLocatorManager.GetSetupDescriptor(service).RegisterWithServiceLocator(service, locator, null); return(service);
}
/// <summary>
/// Registers the with service locator.
/// </summary>
/// <param name="service">The service.</param>
/// <param name="name">The name.</param>
/// <returns></returns>
public static Lazy <IServiceLocator> RegisterWithServiceLocator <T>(this Lazy <IServiceLocator> service, string name)
where T : class, IServiceLocator
{
ServiceLocatorManager.GetSetupDescriptor(service).RegisterWithServiceLocator <T>(service, ServiceLocatorManager.Lazy, name); return(service);
}
/// <summary>
/// Registers the specified service.
/// </summary>
/// <param name="service">The service.</param>
/// <param name="registrant">The registrant.</param>
/// <returns></returns>
public static Lazy <IServiceLocator> Register(this Lazy <IServiceLocator> service, Action <IServiceRegistrar> registrant)
{
ServiceLocatorManager.GetSetupDescriptor(service).Do(l => registrant(l.Registrar)); return(service);
}
