/// <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); }