/// <summary>
/// Returns an instance of DbContext keyed to the API_Name of the passed IEndPointConfiguration.
/// </summary>
/// <param name="helper">An instance of ResolutionHelper.</param>
/// <param name="ep">The IEndPointConfiguration whose properties will be used as keys.</param>
/// <returns>DbContext</returns>
public static DbContext ResolveDbContext(this ResolutionHelper helper, IEndPointConfiguration ep)
{
if (ep == null)
{
throw new ArgumentNullException("ep");
}
IDbContextOptions options = null;
try
{
options = ResolveDbContextOptions(helper, ep);
}
catch (ComponentNotRegisteredException ex)
{
throw new ComponentNotRegisteredException($"DbContext could not be resolved. See InnerException for additional detail.", ex);
}
DbContext context = helper.scope.ResolveOptionalKeyed <DbContext>(ep.API_Name, new TypedParameter(typeof(DbContextOptions), options.Options));
if (context == null)
{
throw new ComponentNotRegisteredException($"DbContext could not be resolved for API_Name {ep.API_Name}. Call RegisterDbContext with an API_Name of {ep.API_Name} to register the required component.");
}
return(context);
}
/// <summary>
/// Registers a client. Call RegisterEndPoints before calling this method.
/// </summary>
/// <typeparam name="TClient">Concrete class that implements TInterface i.e. OrdersClient</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="api_name">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 IRegistrationHelper Register <TClient, TInterface>(string endPointType, string api_name, string providerName)
{
if (String.IsNullOrEmpty(endPointType))
{
throw new ArgumentNullException("endPointType");
}
if (string.IsNullOrEmpty(api_name))
{
throw new ArgumentNullException("api_name");
}
if (providerName == null)
{
providerName = string.Empty;
}
RegisterPerimeter(typeof(TInterface), api_name);
builder.Register <Func <string, string, TInterface> >(c => {
IComponentContext cxt = c.Resolve <IComponentContext>();
return((ept, pn) => ResolutionHelper.ResolveClient <TInterface>(cxt, ept, pn));
});
builder.RegisterType <TClient>().Keyed <TInterface>(endPointType + providerName);
return(this);
}
/// <summary>
/// Returns an implementation of IDbContextOptions keyed to the ProviderName of the passed IEndPointConfiguration.
/// </summary>
/// <param name="helper">An instance of ResolutionHelper.</param>
/// <param name="ep">The IEndPointConfiguration whose properties will be used as keys.</param>
/// <returns>An implementation of IDbContextOptions.</returns>
public static IDbContextOptions ResolveDbContextOptions(this ResolutionHelper helper, IEndPointConfiguration ep)
{
IDbContextOptions options = helper.scope.ResolveOptionalKeyed <IDbContextOptions>(ep.ProviderName, new TypedParameter(typeof(string), ep.ConnectionString));
if (options == null)
{
throw new ComponentNotRegisteredException($"IDbContextOptions have not been registered for ProviderName {ep.ProviderName}. Call RegisterDbContextOptions with a ProviderName of {ep.ProviderName} to register the required component.");
}
return(options);
}
public static TInterface ResolveClient <TInterface>(this ResolutionHelper helper, string ept, string providerName)
{
if (providerName == null)
{
providerName = string.Empty;
}
object result = null;
helper.cxt.TryResolveKeyed(ept + providerName, typeof(TInterface), out result); // Not an error if not resolved.
return((TInterface)result);
}
public static IEndPointValidator ResolveValidator(this ResolutionHelper helper, string endPointType, string providerName)
{
IEndPointValidator result = null;
result = helper.cxt.ResolveOptionalKeyed <IEndPointValidator>(endPointType + providerName);
if (result == null)
{
throw new ComponentNotRegisteredException($"An attempt to resolve an EndPointValidator for EndPointType { endPointType } failed. Use the RegisterEndPointValidator method on the RegistrationHelper to register an EndPointValidator for each EndPointType.");
}
return(result);
}
public static IPerimeter ResolvePerimeter(this ResolutionHelper helper, Type typ)
{
IPerimeter result = null;
result = helper.cxt.ResolveOptionalKeyed <IPerimeter>(typ);
if (result == null)
{
throw new ComponentNotRegisteredException($"Interface { typ.Name } has not been registered. Use RegistrationHelper to register { typ.Name } with one or more implementations, EndPointConfiguration, and API names.");
}
return(result);
}
/// <summary>
/// This overload is primarily for internal use by AdaptiveClient. Resolves an implementation of IDbContextOptions using
/// EndPointContext.CurrentEndPoint which is set internally by AdaptiveClient.
/// </summary>
/// <param name="helper">An instance of ResolutionHelper.</param>
/// <returns>An implementation of IDbContextOptions</returns>
public static IDbContextOptions ResolveDbContextOptions(this ResolutionHelper helper)
{
Func <IEndPointConfiguration> epFactory = helper.scope.Resolve <Func <IEndPointConfiguration> >(); // Registered by AdaptiveClient. Returns EndPointContext.CurrentEndPoint
IEndPointConfiguration ep = epFactory();
if (ep == null)
{
throw new Exception("EndPointContext.CurrentEndPoint is null.");
}
return(ResolveDbContextOptions(helper, ep));
}
/// <summary>
/// Returns a MigrationContext which is a placeholder type that derives from DbContext. The MigrationContext that is
/// returned is keyed to API_Name and ProviderName of the passed IEndPointConfiguration.
/// One or more MigrationContexts might derive from the same DBContext. The type name of each migration context is
/// used by AdaptiveClient as a key for resolving supporting objects such as DbContextOptions. The type name of the
/// migration context is also used by EF itself for creating migrations and updating the
/// database (--context command line option).
/// </summary>
/// <param name="helper">An instance of ResolutionHelper.</param>
/// <param name="ep">The IEndPointConfiguration whose properties will be used as keys.</param>
/// <returns>DbContext</returns>
public static DbContext ResolveMigrationContext(this ResolutionHelper helper, IEndPointConfiguration ep)
{
IDbContextOptions options = null;
try
{
options = ResolveDbContextOptions(helper, ep);
}
catch (ComponentNotRegisteredException)
{
return(null);
}
return(helper.scope.ResolveOptionalKeyed <IMigrationContext>(ep.API_Name + ep.ProviderName, new TypedParameter(typeof(DbContextOptions), options.Options)) as DbContext);
}
/// <summary>
/// Returns an instance of IDatabaseInitializer which is used to seed a database after it is created or a migration is applied. The instance
/// of IDatabaseInitializer that is returned is keyed to the API_Name and ProviderName of the passed IEndPointConfiguration.
/// </summary>
/// <param name="helper">An instance of ResolutionHelper.</param>
/// <param name="ep">The IEndPointConfiguration whose properties will be used as keys.</param>
/// <returns>IDatabaseInitializer</returns>
public static IDatabaseInitializer ResolveDatabaseInitializer(this ResolutionHelper helper, IEndPointConfiguration ep)
{
DbContext context = null;
try
{
context = ResolveDbContext(helper, ep);
}
catch (ComponentNotRegisteredException)
{
return(null);
}
return(helper.scope.ResolveOptionalKeyed <IDatabaseInitializer>(ep.API_Name + ep.ProviderName, new TypedParameter(context.GetType(), context)));
}
protected override void Load(ContainerBuilder builder)
{
base.Load(builder);
builder.RegisterGeneric(typeof(AdaptiveClient <>)).As(typeof(IAdaptiveClient <>)).InstancePerLifetimeScope();
builder.RegisterType <NetworkUtilities>().As <INetworkUtilities>();
builder.Register <Func <IEndPointConfiguration> >(c => { IComponentContext cxt = c.Resolve <IComponentContext>(); return(() => cxt.Resolve <EndPointContext>().CurrentEndPoint); });
builder.Register <Func <Type, IPerimeter> >(c => { IComponentContext cxt = c.Resolve <IComponentContext>(); return(t => ResolutionHelper.ResolvePerimeter(cxt, t)); });
builder.Register <Func <string, string, IEndPointValidator> >(c => { IComponentContext cxt = c.Resolve <IComponentContext>(); return((eptype, providerName) => ResolutionHelper.ResolveValidator(cxt, eptype, providerName)); });
builder.RegisterType <EndPointContext>().InstancePerLifetimeScope(); // per lifetimescope - see notes in EndPointContext.cs
builder.RegisterType <EndPointCache>().SingleInstance(); // singleton
builder.RegisterGeneric(typeof(ClientFactory <>)).As(typeof(IClientFactory <>));
builder.RegisterGeneric(typeof(ClientEvaluator <>)).As(typeof(IClientEvaluator <>));
builder.RegisterInstance <Action <string> >(msg => { }); // default logger. User can override by calling RegistrationHelper.RegisterLogger
}
