/// <summary>
/// Create an Inyector Mode from a AspNetCore ServiceLifetime
/// </summary>
/// <param name="lifetime">lifetime to create the mode</param>
/// <param name="services">Asp.Net Core Service inyection</param>
/// <returns>An Instance of Inyector Mode</returns>
public static Mode Create(ServiceLifetime lifetime, IServiceCollection services)
{
switch (lifetime)
{
case ServiceLifetime.Scoped:
return(new Mode
{
InyectorMethod =
(type, inter) => services.AddScoped(inter, type),
Name = lifetime.ToString()
});
case ServiceLifetime.Singleton:
return(new Mode
{
InyectorMethod =
(type, inter) => services.AddSingleton(inter, type),
Name = lifetime.ToString()
});
case ServiceLifetime.Transient:
return(new Mode
{
InyectorMethod =
(type, inter) => services.AddTransient(inter, type),
Name = lifetime.ToString()
});
default:
throw new ArgumentOutOfRangeException(nameof(lifetime), lifetime, null);
}
}
public AndConstraint <ServiceCollectionAssertions> BeRegistered(Type serviceType, Type implementationType, ServiceLifetime lifetime, string because = "", params object[] becauseArgs)
{
AssertionScope scope = Execute.Assertion;
scope.AddReportable("lifetime", lifetime.ToString().ToLowerInvariant());
scope
.BecauseOf(because, becauseArgs)
.WithExpectation("Expected {context:service collection} to contain a {lifetime} registration for {0} implemented by {1}{reason}, ", serviceType, implementationType)
// Match service and lifetime
.Given(() => Subject.Where(d => d.ServiceType == serviceType))
.ForCondition(reg => reg.Any())
.FailWith("but the service was not found.")
.Then
.ForCondition(reg => reg.Any(d => d.Lifetime == lifetime))
.FailWith("but found {0}.", reg => reg.Select(d => d.Lifetime).Distinct())
.Then
.Given(reg => reg.FirstOrDefault(d => d.Lifetime == lifetime))
.ForCondition(r =>
// Match implementation, instance or factory
r.ImplementationType == implementationType ||
r.ImplementationInstance != null && implementationType.IsInstanceOfType(r.ImplementationInstance) ||
r.ImplementationFactory != null
)
.FailWith("but it does not.")
;
return(new AndConstraint <ServiceCollectionAssertions>(this));
}
public ICallistoCollectionConfigurator ConfigureCollection <TInterface, TConcrete,
TDocumentRoot>(string database,
string collection,
ServiceLifetime lifetime,
Func <IServiceProvider, object[]> extraDependencies = null)
where TDocumentRoot : class, IDocumentRoot
where TConcrete : CallistoCollection <TDocumentRoot>, TInterface
{
ConfigureCollectionContext <TDocumentRoot>(database, collection, lifetime);
_solariBuilder.Services.Add(ServiceDescriptor.Describe(typeof(TInterface), provider =>
{
CallistoLogger.CollectionLogger.Registering(collection, lifetime.ToString());
var context = provider.GetRequiredService <ICallistoCollectionContext <TDocumentRoot> >();
CollectionOperators <TDocumentRoot> operators = CreateCollectionOperators <TInterface, TConcrete, TDocumentRoot>(context.Collection, provider);
if (extraDependencies is null)
{
return(ActivatorUtilities.CreateInstance <TConcrete>(provider, context, operators));
}
object[] extra = extraDependencies(provider);
return(ActivatorUtilities.CreateInstance <TConcrete>(provider, context, operators, extra));
}, lifetime));
return(this);
}
/// <summary>
/// Apply a Naming convention rule with an Assembly
/// example : ICarRepository match with CarRepository
/// </summary>
/// <param name="configuration"></param>
/// <param name="assembly">Assembly to apply rule</param>
/// <param name="lifetime">AspNet Core mode to inyect </param>
/// <returns>a instance of IInyectorConfiguration</returns>
public static InyectorConfiguration AddRuleForNamingConvention(this InyectorConfiguration configuration,
Assembly assembly,
ServiceLifetime lifetime)
{
configuration.AddRule(assembly, (t1, t2) => $"I{t1.Name}" == t2.Name, lifetime.ToString());
return(configuration);
}
/// <summary>
/// Add Rule from LifeTime using the default models and a target Assembly
/// </summary>
/// <param name="configuration"></param>
/// <param name="assembly">Assembly to apply the rule</param>
/// <param name="criteria">Criteria to find the types</param>
/// <param name="lifetime">lifetime</param>
/// <returns></returns>
public static InyectorConfiguration AddRule(this InyectorConfiguration configuration,
Assembly assembly,
Func <Type, Type, bool> criteria,
ServiceLifetime lifetime)
{
configuration.AddRule(assembly, criteria, lifetime.ToString());
return(configuration);
}
/// <summary>
/// Apply a Naming convention rule with an assembly
/// with ends with names example only inyect classes that finish with [Repository, Helper, Services, Factory, and so
/// on...]
/// example : ICarRepository match with CarRepository
/// </summary>
/// <param name="configuration"></param>
/// <param name="assembly">Assembly to apply rule</param>
/// <param name="names">names to find is the type name finish with</param>
/// <param name="lifetime">AspNet Core mode to inyect </param>
/// <returns>a instance of IInyectorConfiguration</returns>
public static InyectorConfiguration AddRuleForEndsWithNamingConvention(this InyectorConfiguration configuration,
Assembly assembly,
IEnumerable <string> names,
ServiceLifetime lifetime)
{
configuration.AddRule(assembly, (t1, t2) => names.Any(n => t1.Name.ToLower().EndsWith(n.ToLower())) &&
$"I{t1.Name}" == t2.Name,
lifetime.ToString());
return(configuration);
}
private static LifetimeManager GetLifetimeManager(ServiceLifetime lifecycle)
{
switch (lifecycle)
{
case ServiceLifetime.Singleton:
return(new ContainerControlledLifetimeManager());
case ServiceLifetime.Scoped:
return(new HierarchicalLifetimeManager());
case ServiceLifetime.Transient:
return(new TransientLifetimeManager());
default:
throw new NotSupportedException(lifecycle.ToString());
}
}
/// <summary>
/// Add all classes which inherits or implements the base type from the specific assembly.
/// </summary>
/// <param name="services">Service collection.</param>
/// <param name="baseType">Base type.</param>
/// <param name="assembly"><see cref="Assembly"/> in which to search.</param>
/// <param name="serviceLifetime"><see cref="ServiceLifetime"/> with which the founded classes to be added.</param>
/// <returns>Returns <see cref="IServiceCollection"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when services, baseType or assembly is null.</exception>
/// <exception cref="ArgumentException">Thrown when serviceLifeTime is different from <see cref="ServiceLifetime.Transient"/>, <see cref="ServiceLifetime.Scoped"/> or <see cref="ServiceLifetime.Singleton"/>.</exception>
/// <example>
/// This is an example, showing how to use <see cref="AddAll(IServiceCollection, Type, Assembly, ServiceLifetime)"/>.
/// <code>
/// services.AddAll(typeof(IDbService), Assembly.GetAssembly(typeof(IDbService)), ServiceLifeTime.Scoped);
/// </code>
/// </example>
public static IServiceCollection AddAll(this IServiceCollection services, Type baseType, Assembly assembly, ServiceLifetime serviceLifetime = ServiceLifetime.Transient)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services), "Services cannot be null.");
}
if (baseType == null)
{
throw new ArgumentNullException(nameof(baseType), "Base type cannot be null.");
}
if (assembly == null)
{
throw new ArgumentNullException(nameof(assembly), "Assembly cannot be null.");
}
assembly.GetExportedTypes()
.ForEach(t =>
{
if (!t.IsAbstract &&
((baseType.IsInterface && t.ImplementsInterface(baseType)) ||
(!baseType.IsInterface && baseType.IsAssignableFrom(t))))
{
switch (serviceLifetime)
{
case ServiceLifetime.Singleton:
services.AddSingleton(t);
break;
case ServiceLifetime.Scoped:
services.AddScoped(t);
break;
case ServiceLifetime.Transient:
services.AddTransient(t);
break;
default:
throw new ArgumentException($"Unsupported ServiceLifeTime enum value: {serviceLifetime.ToString()}.", nameof(serviceLifetime));
}
}
});
return(services);
}