/// <summary> /// Register Perimeter by name using service interface as key. /// </summary> /// <param name="serviceInterface">Type of interface i.e. IUsersService</param> /// <param name="api_name">Name of API that implements passed service interface</param> public static void RegisterPerimeter(this RegistrationHelper helper, Type serviceInterface, string api_name) { IPerimeter perimeter; helper.EndPointDict.TryGetValue(api_name, out perimeter); if (perimeter == null) { throw new Exception($"A Perimeter named {api_name} was not found. Call RegisterEndPoints before calling Register."); } string existingAPIRegistration = null; helper.ServiceRegistrations.TryGetValue(serviceInterface.FullName, out existingAPIRegistration); if (existingAPIRegistration != null && existingAPIRegistration != api_name) { throw new Exception($"A service type can be registered with only one API. Type {serviceInterface.Name} has been registered with an API named {existingAPIRegistration}. A second attempt to register the same type with API {api_name} is being made."); } else if (existingAPIRegistration == null) { helper.ServiceRegistrations.Add(serviceInterface.FullName, api_name); } helper.Builder.RegisterInstance <IPerimeter>(perimeter).Keyed <IPerimeter>(serviceInterface); }
/// <summary> /// Registers a service. Call RegisterEndPoints before calling this method. /// </summary> /// <typeparam name="TService">Concrete class that implements TInterface i.e. OrdersService</typeparam> /// <typeparam name="TInterface">Interface of service i.e. IOrdersService</typeparam> /// <param name="endPointType">Type of client that will access this service i.e. HTTP, InProcess, WCF</param> /// <param name="apiName">API_Name of EndPointConfiguration objects TInterface</param> /// <param name="providerName">Similar to provider name in a connection string, describes technology provider i.e. MSSQL, MySQL, SQLNCLI, etc.</param> public static RegistrationHelper RegisterService <TService, TInterface>(this RegistrationHelper helper, string endPointType, string apiName, string providerName) { if (String.IsNullOrEmpty(endPointType)) { throw new ArgumentNullException(nameof(endPointType)); } if (string.IsNullOrEmpty(apiName)) { throw new ArgumentNullException(nameof(apiName)); } if (providerName == null) { providerName = string.Empty; } RegisterPerimeter(helper, typeof(TInterface), apiName); helper.Builder.Register <Func <string, string, TInterface> >(c => { ILifetimeScope cxt = c.Resolve <ILifetimeScope>(); return((ept, pn) => new ResolutionHelper(cxt).ResolveClient <TInterface>(ept, pn)); }); helper.Builder.RegisterType <TService>().Keyed <TInterface>(endPointType + providerName); return(helper); }
/// <summary> /// Registers a service. Call RegisterEndPoints before calling this method. /// </summary> /// <typeparam name="TService">Concrete class that implements TInterface i.e. OrdersService</typeparam> /// <typeparam name="TInterface">Interface of service i.e. IOrdersService</typeparam> /// <param name="endPoint">IEndPointConfiguration with EndPointType, API_Name, and providerName to use as keys</param> public static RegistrationHelper RegisterService <TService, TInterface>(this RegistrationHelper helper, IEndPointConfiguration endPoint) { if (endPoint == null) { throw new ArgumentNullException(nameof(endPoint)); } RegisterService <TService, TInterface>(helper, endPoint.EndPointType, endPoint.API_Name, endPoint.ProviderName); return(helper); }
/// <summary> /// Registers an implementation of IDbContextOptions keyed to the supplied providerName. /// </summary> /// <typeparam name="TOptions">Type that implements IDbContextOptions.</typeparam> /// <param name="helper">An instance of RegistrationHelper.</param> /// <param name="providerName">ProviderName typically represents some implementation of technology such as a DBMS platform. /// Examples might be: MSSQL, MySQL, SQLite, etc.</param> /// <returns>RegistrationHelper</returns> public static RegistrationHelper RegisterDbContextOptions <TOptions>(this RegistrationHelper helper, string providerName) where TOptions : IDbContextOptions { if (string.IsNullOrEmpty(providerName)) { throw new ArgumentNullException("providerName"); } helper.Builder.RegisterType <TOptions>().Keyed <IDbContextOptions>(providerName); return(helper); }
/// <summary> /// Registers a validator for a given EndPointType. A validator is used to determine if an EndPoint is alive and able to handle requests. /// </summary> /// <typeparam name="TValidator">The implementation of IEndPointValidator that will handle validation requests for the specified EndPointType</typeparam> /// <param name="endPointType">The type of EndPoint that will be validated by the specified implementation of IEndPointValidator</param> /// <returns></returns> public static RegistrationHelper RegisterEndPointValidator <TValidator>(this RegistrationHelper helper, string endPointType, string providerName) where TValidator : IEndPointValidator { if (String.IsNullOrEmpty(endPointType)) { throw new ArgumentNullException(nameof(endPointType)); } if (string.IsNullOrEmpty(providerName)) { throw new ArgumentNullException(nameof(providerName)); } helper.Builder.RegisterType <TValidator>().Keyed <IEndPointValidator>(endPointType + providerName); return(helper); }
public static RegistrationHelper RegisterModule(this RegistrationHelper helper, params IAdaptiveClientModule[] modules) { if (!modules?.Any() ?? false) { return(helper); } foreach (IAdaptiveClientModule module in modules) { module.Register(helper); } return(helper); }
/// <summary> /// Registers an implementation of IDatabaseinitializer, an object that is used to initialize or seed a database after it is created or migrations are applied. /// </summary> /// <typeparam name="TInitalizer">Type that implements IDatabaseInitializer.</typeparam> /// <param name="helper">An instance of RegistrationHelper.</param> /// <param name="apiName">An API_Name to use as a key. Must match the API_Name of one or more IEndPointConfiguration objects. /// API_Name is an arbitrary name given to the collection of services exposed by an API. /// The name of a database or a domain name are examples of names that might also be used as an API_Name. </param> /// <param name="providerName">ProviderName typically represents some implementation of technology such as a DBMS platform. /// Examples might be: MSSQL, MySQL, SQLite, etc.</param> /// <returns>RegistrationHelper</returns> public static RegistrationHelper RegisterDatabaseInitializer <TInitalizer>(this RegistrationHelper helper, string apiName, string providerName) where TInitalizer : IDatabaseInitializer { if (string.IsNullOrEmpty(apiName)) { throw new ArgumentNullException("apiName"); } if (string.IsNullOrEmpty(providerName)) { throw new ArgumentNullException("providerName"); } helper.Builder.RegisterType <TInitalizer>().Keyed <IDatabaseInitializer>(apiName + providerName); return(helper); }
/// <summary> /// Registers an implementation of IMigrationContext. A MigrationContext is a placeholder type that allows AdaptiveClient to associate an API_Name /// and ProviderName with specific implementations of DbContext and DbContextOptions. /// </summary> /// <typeparam name="TContext">Type that derives from DbContext and implements IMigratinContext.</typeparam> /// <param name="helper">An instance of RegistrationHelper.</param> /// <param name="apiName">An API_Name to use as a key. Must match the API_Name of one or more IEndPointConfiguration objects. /// API_Name is an arbitrary name given to the collection of services exposed by an API. /// The name of a database or a domain name are examples of names that might also be used as an API_Name. </param> /// <param name="providerName">ProviderName typically represents some implementation of technology such as a DBMS platform. /// Examples might be: MSSQL, MySQL, SQLite, etc.</param> /// <returns>RegistrationHelper</returns> public static RegistrationHelper RegisterMigrationContext <TContext>(this RegistrationHelper helper, string apiName, string providerName) where TContext : DbContext, IMigrationContext { if (string.IsNullOrEmpty(apiName)) { throw new ArgumentNullException("apiName"); } if (string.IsNullOrEmpty(providerName)) { throw new ArgumentNullException("providerName"); } helper.Builder.RegisterType <TContext>().Keyed <IMigrationContext>(apiName + providerName); return(helper); }
/// <summary> /// Registers a class that derives from DbContext using the supplied apiName as a key. /// </summary> /// <typeparam name="TContext">Type that derives from DbContext.</typeparam> /// <param name="helper">An instance of RegistrationHelper.</param> /// <param name="apiName">An API_Name to use as a key. Must match the API_Name of one or more IEndPointConfiguration objects. /// API_Name is an arbitrary name given to the collection of services exposed by an API. /// The name of a database or a domain name are examples of names that might also be used as an API_Name.</param> /// <returns>RegistrationHelper</returns> public static RegistrationHelper RegisterDbContext <TContext>(this RegistrationHelper helper, string apiName) where TContext : DbContext { if (string.IsNullOrEmpty(apiName)) { throw new ArgumentNullException("apiName"); } helper.Builder.RegisterType <TContext>().InstancePerLifetimeScope(); // DbContext is normally injected into a service - no key needed // For when we have an endPoint and we need to know what DbContext is associated. // We do not want InstancePerLifetimeScope here - when looping through a collection of EndPoints // we want a new instance for each endpoint. helper.Builder.RegisterType <TContext>().Keyed <DbContext>(apiName).UsingConstructor(typeof(DbContextOptions)); return(helper); }
/// <summary> /// Registers a collection of EndPointConfiguration objects. /// </summary> /// <param name="endPoints">Collection of EndPointConfiguration objects</param> public static RegistrationHelper RegisterEndPoints(this RegistrationHelper helper, IEnumerable <IEndPointConfiguration> endPoints) { if (endPoints == null) { throw new ArgumentNullException(nameof(endPoints)); } // Do not register endpoints with the container. A list of endpoints is available when a Perimeter is resolved. endPoints = endPoints.Where(x => x.IsActive); EndPointUtilities.ValidateEndPoints(endPoints); foreach (var perimeter in endPoints.GroupBy(x => x.API_Name)) { helper.EndPointDict.Add(perimeter.Key, new Perimeter(perimeter.Key, perimeter.ToList())); } return(helper); }
/// <summary> /// Registers an Action that accepts logging messages. /// </summary> /// <param name="logger"></param> public static RegistrationHelper RegisterLogger(this RegistrationHelper helper, Action <string> logger) { helper.Builder.RegisterInstance <Action <string> >(logger); return(helper); }
/// <summary> /// Registers a ServiceManifest, a class that exposes a property for each type of service associated with an API. A ServiceManifest is keyed to an EndPointType, an API_Name, and a ProviderName. /// </summary> /// <typeparam name="TService">Type of service manifest. Must derive from ServiceManifestFactory.</typeparam> /// <typeparam name="TInterface">Interface that describes TService.</typeparam> /// <param name="helper">An instance of RegistrationHelper.</param> /// <param name="endPointType">Describes the technology or protocol used by an IEndPointConfiguration.</param> /// <param name="apiName">An API_Name to use as a key. Must match the API_Name of one or more IEndPointConfiguration objects. /// API_Name is an arbitrary name given to the collection of services exposed by an API. /// The name of a database or a domain name are examples of names that might also be used as an API_Name. </param> /// <param name="providerName">ProviderName typically represents some implementation of technology such as a DBMS platform. /// Examples might be: MSSQL, MySQL, SQLite, etc.</param> /// <returns></returns> public static RegistrationHelper RegisterServiceManifest <TService, TInterface>(this RegistrationHelper helper, string endPointType, string apiName, string providerName) where TService : ServiceManifestFactory { if (string.IsNullOrEmpty(endPointType)) { throw new ArgumentNullException(nameof(endPointType)); } if (string.IsNullOrEmpty(apiName)) { throw new ArgumentNullException(nameof(apiName)); } if (string.IsNullOrEmpty(providerName)) { throw new ArgumentNullException(nameof(providerName)); } helper.RegisterPerimeter(typeof(TInterface), apiName); helper.Builder.Register <Func <string, string, TInterface> >(c => { ILifetimeScope cxt = c.Resolve <ILifetimeScope>(); return((ept, pn) => new ResolutionHelper(cxt).ResolveClient <TInterface>(ept, pn)); }).PropertiesAutowired(); helper.Builder.RegisterType <TService>().Keyed <TInterface>(endPointType + providerName).PropertiesAutowired().InstancePerLifetimeScope(); helper.Builder.RegisterType <TService>().As <TInterface>().PropertiesAutowired().InstancePerLifetimeScope(); return(helper); }