/// <summary>
/// Register Module
/// </summary>
/// <param name="services">services</param>
/// <param name="module">service module</param>
/// <returns>services</returns>
public static IServiceContainerBuilder RegisterModule <TServiceModule>(this IServiceContainerBuilder services, TServiceModule module)
where TServiceModule : IServiceContainerModule
{
Guard.NotNull(module, nameof(module));
module.ConfigureServices(services);
return(services);
}
/// <summary>
/// RegisterAssemblyTypes
/// </summary>
/// <param name="services">services</param>
/// <param name="typesFilter">filter types to register</param>
/// <param name="serviceLifetime">service lifetime</param>
/// <param name="assemblies">assemblies</param>
/// <returns>services</returns>
public static IServiceContainerBuilder RegisterAssemblyTypes([NotNull] this IServiceContainerBuilder services, Func <Type, bool> typesFilter, ServiceLifetime serviceLifetime, params Assembly[] assemblies)
{
if (assemblies == null || assemblies.Length == 0)
{
assemblies = ReflectHelper.GetAssemblies();
}
var types = assemblies
.Select(assembly => assembly.GetTypes())
.SelectMany(t => t)
.Where(t => !t.IsAbstract)
;
if (typesFilter != null)
{
types = types.Where(typesFilter);
}
foreach (var type in types)
{
services.Add(new ServiceDefinition(type, type, serviceLifetime));
}
return(services);
}
public static IServiceContainerBuilder RegisterAssemblyModules(
[NotNull] this IServiceContainerBuilder serviceContainerBuilder, params Assembly[] assemblies)
{
if (null == assemblies || assemblies.Length == 0)
{
assemblies = ReflectHelper.GetAssemblies();
}
foreach (var type in assemblies.
SelectMany(ass => ass.GetExportedTypes())
.Where(t => t.IsClass && !t.IsAbstract && typeof(IServiceContainerModule).IsAssignableFrom(t))
)
{
try
{
if (Activator.CreateInstance(type) is IServiceContainerModule module)
{
module.ConfigureServices(serviceContainerBuilder);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
return(serviceContainerBuilder);
}
public static IServiceContainerBuilder AddProxyService <TService>(this IServiceContainerBuilder serviceCollection, ServiceLifetime serviceLifetime)
where TService : class
{
serviceCollection.Add(new ServiceDefinition(typeof(TService), sp =>
{
var proxyFactory = sp.ResolveRequiredService <IProxyFactory>();
return(proxyFactory.CreateProxy <TService>());
}, serviceLifetime));
return(serviceCollection);
}
/// <summary>
/// RegisterTypeAsImplementedInterfaces
/// </summary>
/// <param name="services">services</param>
/// <param name="type">type</param>
/// <param name="serviceLifetime">service lifetime</param>
/// <returns>services</returns>
public static IServiceContainerBuilder RegisterTypeAsImplementedInterfaces([NotNull] this IServiceContainerBuilder services, Type type, ServiceLifetime serviceLifetime = ServiceLifetime.Singleton)
{
if (type != null)
{
foreach (var interfaceType in type.GetImplementedInterfaces())
{
services.Add(new ServiceDefinition(interfaceType, type, serviceLifetime));
}
}
return(services);
}
/// <summary>
/// RegisterTypeAsImplementedInterfaces
/// </summary>
/// <param name="services">services</param>
/// <param name="type">type</param>
/// <param name="interfaceTypeFilter">interfaceTypeFilter</param>
/// <param name="serviceLifetime">service lifetime</param>
/// <returns>services</returns>
public static IServiceContainerBuilder RegisterTypeAsImplementedInterfaces(this IServiceContainerBuilder services, Type type, Func <Type, bool>?interfaceTypeFilter, ServiceLifetime serviceLifetime = ServiceLifetime.Singleton)
{
Guard.NotNull(type);
foreach (var interfaceType in type.GetImplementedInterfaces())
{
if (interfaceTypeFilter?.Invoke(interfaceType) != false)
{
services.Add(new ServiceDefinition(interfaceType, type, serviceLifetime));
}
}
return(services);
}
public static IFluentAspectsServiceContainerBuilder AddFluentAspects(this IServiceContainerBuilder serviceCollection)
{
if (null == serviceCollection)
{
throw new ArgumentNullException(nameof(serviceCollection));
}
serviceCollection.AddTransient <IProxyTypeFactory, DefaultProxyTypeFactory>();
serviceCollection.AddTransient <IProxyFactory, DefaultProxyFactory>();
serviceCollection.AddSingleton(FluentConfigInterceptorResolver.Instance);
return(new FluentAspectsServiceContainerBuilder(serviceCollection));
}
public static IFluentAspectsServiceContainerBuilder AddFluentAspects(this IServiceContainerBuilder serviceCollection, Action <FluentAspectOptions> optionsAction)
{
if (null == serviceCollection)
{
throw new ArgumentNullException(nameof(serviceCollection));
}
if (null == optionsAction)
{
throw new ArgumentNullException(nameof(optionsAction));
}
FluentAspects.Configure(optionsAction);
return(AddFluentAspects(serviceCollection));
}
public static IServiceContainerBuilder RegisterAssemblyModules(
[NotNull] this IServiceContainerBuilder serviceContainerBuilder, params Assembly[] assemblies)
{
#if NET45
if (null == assemblies || assemblies.Length == 0)
{
if (System.Web.Hosting.HostingEnvironment.IsHosted)
{
assemblies = System.Web.Compilation.BuildManager.GetReferencedAssemblies()
.Cast <Assembly>().ToArray();
}
}
#endif
if (null == assemblies || assemblies.Length == 0)
{
assemblies = AppDomain.CurrentDomain.GetAssemblies();
}
foreach (var type in assemblies.WhereNotNull().SelectMany(ass => ass.GetTypes())
.Where(t => t.IsClass && !t.IsAbstract && typeof(IServiceContainerModule).IsAssignableFrom(t))
)
{
try
{
if (Activator.CreateInstance(type) is ServiceContainerModule module)
{
module.ConfigureServices(serviceContainerBuilder);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
return(serviceContainerBuilder);
}
/// <summary>
/// RegisterTypeAsImplementedInterfaces
/// </summary>
/// <param name="services">services</param>
/// <param name="type">type</param>
/// <param name="serviceLifetime">service lifetime</param>
/// <returns>services</returns>
public static IServiceContainerBuilder RegisterTypeAsImplementedInterfaces(
[NotNull] this IServiceContainerBuilder services, Type type,
ServiceLifetime serviceLifetime = ServiceLifetime.Singleton)
=> RegisterTypeAsImplementedInterfaces(services, type, null, serviceLifetime);
/// <summary>
/// RegisterAssemblyTypes
/// </summary>
/// <param name="services">services</param>
/// <param name="serviceLifetime">service lifetime</param>
/// <param name="assemblies">assemblies</param>
/// <returns>services</returns>
public static IServiceContainerBuilder RegisterAssemblyTypes([NotNull] this IServiceContainerBuilder services,
ServiceLifetime serviceLifetime, params Assembly[] assemblies)
=> RegisterAssemblyTypes(services, null, serviceLifetime, assemblies);
public ServiceContainerDependencyResolver(IServiceContainerBuilder serviceContainerBuilder) : this(serviceContainerBuilder.Build())
{
}
public static void SetDependencyResolver([NotNull] IServiceContainerBuilder serviceContainerBuilder) => SetDependencyResolver(new ServiceContainerDependencyResolver(serviceContainerBuilder));
public static IServiceContainerBuilder AddTransientProxy <TService>(this IServiceContainerBuilder serviceCollection)
where TService : class =>
serviceCollection.AddProxyService <TService>(ServiceLifetime.Transient);
public static IServiceContainer BuildFluentAspectsContainer(this IServiceContainerBuilder serviceCollection,
Action <FluentAspectOptions> optionsAction,
Action <IFluentAspectsServiceContainerBuilder> aspectBuildAction = null,
Expression <Func <Type, bool> > ignoreTypesFilter = null)
{
var services = new ServiceContainerBuilder();
var aspectBuilder = null != optionsAction
? serviceCollection.AddFluentAspects(optionsAction)
: serviceCollection.AddFluentAspects();
aspectBuildAction?.Invoke(aspectBuilder);
Expression <Func <Type, bool> > ignoreTypesExpression = t => "WeihanLi.Common.Aspect".Equals(t.Namespace);
if (null != ignoreTypesFilter)
{
ignoreTypesExpression = ignoreTypesExpression.Or(ignoreTypesFilter);
}
var ignoreTypesPredicate = ignoreTypesExpression.Compile();
using (var serviceProvider = serviceCollection.Build())
{
var proxyTypeFactory = serviceProvider.ResolveRequiredService <IProxyTypeFactory>();
foreach (var descriptor in serviceCollection)
{
if (descriptor.ServiceType.IsSealed ||
descriptor.ServiceType.IsNotPublic ||
descriptor.ServiceType.IsGenericTypeDefinition
)
{
services.Add(descriptor);
continue;
}
if (ignoreTypesPredicate(descriptor.ServiceType))
{
services.Add(descriptor);
continue;
}
if (descriptor.ImplementType != null)
{
if (descriptor.ImplementType.IsNotPublic ||
descriptor.ImplementType.IsProxyType()
)
{
services.Add(descriptor);
continue;
}
if (descriptor.ServiceType.IsClass &&
descriptor.ImplementType.IsSealed)
{
services.Add(descriptor);
continue;
}
if (descriptor.ServiceType.IsGenericTypeDefinition ||
descriptor.ImplementType.IsGenericTypeDefinition)
{
var proxyType = proxyTypeFactory.CreateProxyType(descriptor.ServiceType, descriptor.ImplementType);
services.Add(new ServiceDefinition(descriptor.ServiceType, proxyType,
descriptor.ServiceLifetime));
continue;
}
}
Func <IServiceProvider, object> serviceFactory = null;
if (descriptor.ImplementationInstance != null)
{
if (descriptor.ImplementationInstance.GetType().IsPublic)
{
serviceFactory = provider => provider.ResolveRequiredService <IProxyFactory>()
.CreateProxyWithTarget(descriptor.ServiceType, descriptor.ImplementationInstance);
}
}
else if (descriptor.ImplementType != null)
{
serviceFactory = provider =>
{
var proxy = provider.ResolveRequiredService <IProxyFactory>()
.CreateProxy(descriptor.ServiceType, descriptor.ImplementType);
return(proxy);
};
}
else if (descriptor.ImplementationFactory != null)
{
serviceFactory = provider =>
{
var implement = descriptor.ImplementationFactory(provider);
if (implement == null)
{
return(null);
}
var implementType = implement.GetType();
if (implementType.IsNotPublic ||
implementType.IsProxyType())
{
return(implement);
}
return(provider.ResolveRequiredService <IProxyFactory>()
.CreateProxyWithTarget(descriptor.ServiceType, implement));
};
}
if (null != serviceFactory)
{
services.Add(new ServiceDefinition(descriptor.ServiceType, serviceFactory,
descriptor.ServiceLifetime));
}
else
{
services.Add(descriptor);
}
}
}
var container = services.Build();
DependencyResolver.SetDependencyResolver(container);
return(container);
}
/// <summary>
/// Register Module
/// </summary>
/// <param name="services">services</param>
/// <param name="module">service module</param>
/// <returns>services</returns>
public static IServiceContainerBuilder RegisterModule <TServiceModule>([NotNull] this IServiceContainerBuilder services, TServiceModule module)
where TServiceModule : IServiceContainerModule
{
module?.ConfigureServices(services);
return(services);
}
/// <summary>
/// RegisterTypeAsImplementedInterfaces
/// </summary>
/// <param name="services">services</param>
/// <param name="typesFilter">filter types to register</param>
/// <param name="interfaceTypeFilter">filter interface types to register</param>
/// <param name="serviceLifetime">service lifetime</param>
/// <param name="assemblies">assemblies</param>
/// <returns>services</returns>
public static IServiceContainerBuilder RegisterAssemblyTypesAsImplementedInterfaces(this IServiceContainerBuilder services, Func <Type, bool>?typesFilter, Func <Type, bool>?interfaceTypeFilter, ServiceLifetime serviceLifetime, params Assembly[] assemblies)
{
Guard.NotNull(assemblies, nameof(assemblies));
if (assemblies.Length == 0)
{
assemblies = ReflectHelper.GetAssemblies();
}
var types = assemblies
.Select(assembly => assembly.GetTypes())
.SelectMany(t => t)
.Where(t => !t.IsAbstract)
;
if (typesFilter != null)
{
types = types.Where(typesFilter);
}
foreach (var type in types)
{
foreach (var implementedInterface in type.GetImplementedInterfaces())
{
if (interfaceTypeFilter?.Invoke(implementedInterface) != false)
{
services.Add(new ServiceDefinition(implementedInterface, type, serviceLifetime));
}
}
}
return(services);
}
public static IServiceContainerBuilder AddSingleton <TService>([NotNull] this IServiceContainerBuilder serviceContainerBuilder, [NotNull] TService service)
{
serviceContainerBuilder.Add(new ServiceDefinition(service, typeof(TService)));
return(serviceContainerBuilder);
}
public FluentAspectsServiceContainerBuilder(IServiceContainerBuilder serviceCollection)
{
Services = serviceCollection;
}
/// <summary> /// RegisterAssemblyTypes /// </summary> /// <param name="services">services</param> /// <param name="assemblies">assemblies</param> /// <returns>services</returns> public static IServiceContainerBuilder RegisterAssemblyTypes(this IServiceContainerBuilder services, params Assembly[] assemblies) => RegisterAssemblyTypes(services, null, ServiceLifetime.Singleton, assemblies);
/// <summary>
/// RegisterTypeAsImplementedInterfaces
/// </summary>
/// <param name="services">services</param>
/// <param name="assemblies">assemblies</param>
/// <returns>services</returns>
public static IServiceContainerBuilder RegisterAssemblyTypesAsImplementedInterfaces(this IServiceContainerBuilder services,
params Assembly[] assemblies)
=> RegisterAssemblyTypesAsImplementedInterfaces(services, typesFilter: null, ServiceLifetime.Singleton, assemblies);
public static IServiceContainerBuilder AddSingleton <TService>(this IServiceContainerBuilder serviceContainerBuilder, TService service)
{
Guard.NotNull(service, nameof(service));
serviceContainerBuilder.Add(new ServiceDefinition(service !, typeof(TService)));
return(serviceContainerBuilder);
}
/// <summary>
/// RegisterTypeAsImplementedInterfaces
/// </summary>
/// <param name="services">services</param>
/// <param name="serviceLifetime">service lifetime</param>
/// <param name="assemblies">assemblies</param>
/// <returns>services</returns>
public static IServiceContainerBuilder RegisterAssemblyTypesAsImplementedInterfaces([NotNull] this IServiceContainerBuilder services,
ServiceLifetime serviceLifetime, params Assembly[] assemblies)
=> RegisterAssemblyTypesAsImplementedInterfaces(services, typesFilter: null, serviceLifetime, assemblies);
public abstract void ConfigureServices(IServiceContainerBuilder serviceContainerBuilder);
public static IServiceContainerBuilder AddTransientProxy <TService, TImplement>(this IServiceContainerBuilder serviceCollection)
where TImplement : TService
where TService : class
{
return(serviceCollection.AddProxyService <TService, TImplement>(ServiceLifetime.Transient));
}
/// <summary>
/// RegisterTypeAsImplementedInterfaces
/// </summary>
/// <param name="services">services</param>
/// <param name="typesFilter">filter types to register</param>
/// <param name="serviceLifetime">service lifetime</param>
/// <param name="assemblies">assemblies</param>
/// <returns>services</returns>
public static IServiceContainerBuilder RegisterAssemblyTypesAsImplementedInterfaces(
this IServiceContainerBuilder services, Func <Type, bool>?typesFilter,
ServiceLifetime serviceLifetime, params Assembly[] assemblies)
=> RegisterAssemblyTypesAsImplementedInterfaces(services, typesFilter, null, serviceLifetime, assemblies);
/// <summary>
/// RegisterAssemblyTypes
/// </summary>
/// <param name="services">services</param>
/// <param name="typesFilter">filter types to register</param>
/// <param name="assemblies">assemblies</param>
/// <returns>services</returns>
public static IServiceContainerBuilder RegisterAssemblyTypes([NotNull] this IServiceContainerBuilder services,
Func <Type, bool> typesFilter, params Assembly[] assemblies)
=> RegisterAssemblyTypes(services, typesFilter, ServiceLifetime.Singleton, assemblies);
public static IServiceContainerBuilder AddScopedProxy <TService>(this IServiceContainerBuilder serviceCollection)
where TService : class =>
serviceCollection.AddProxyService <TService>(ServiceLifetime.Scoped);
public override void ConfigureServices(IServiceContainerBuilder serviceContainerBuilder)
{
serviceContainerBuilder.AddSingleton <IIdGenerator>(GuidIdGenerator.Instance);
}
public static IServiceContainer BuildFluentAspectsContainer(this IServiceContainerBuilder serviceCollection,
Action <FluentAspectOptions> optionsAction,
Action <IFluentAspectsServiceContainerBuilder> aspectBuildAction = null,
Func <Type, bool> ignoreTypesPredict = null)
{
var services = new ServiceContainerBuilder();
var aspectBuilder = null != optionsAction
? services.AddFluentAspects(optionsAction)
: services.AddFluentAspects();
aspectBuildAction?.Invoke(aspectBuilder);
foreach (var descriptor in serviceCollection)
{
if (ignoreTypesPredict?.Invoke(descriptor.ServiceType) == true)
{
services.Add(descriptor);
continue;
}
if (descriptor.ServiceType.IsSealed ||
descriptor.ImplementType.IsProxyType() ||
(descriptor.ServiceType.IsClass && (descriptor.ImplementType?.IsSealed == true || descriptor.ImplementType?.IsPublic == false)))
{
services.Add(descriptor);
}
else
{
Func <IServiceProvider, object> serviceFactory = null;
if (descriptor.ImplementationInstance != null)
{
serviceFactory = provider => provider.ResolveRequiredService <IProxyFactory>()
.CreateProxyWithTarget(descriptor.ServiceType, descriptor.ImplementationInstance);
}
else if (descriptor.ImplementationFactory != null)
{
serviceFactory = provider =>
{
var implement = descriptor.ImplementationFactory(provider);
if (implement?.GetType().IsProxyType() == true)
{
return(implement);
}
return(provider.ResolveRequiredService <IProxyFactory>()
.CreateProxyWithTarget(descriptor.ServiceType, implement));
};
}
else if (descriptor.ImplementType != null)
{
serviceFactory = provider => provider.ResolveRequiredService <IProxyFactory>()
.CreateProxy(descriptor.ServiceType, descriptor.ImplementType);
}
if (null != serviceFactory)
{
services.Add(new ServiceDefinition(descriptor.ServiceType, serviceFactory,
descriptor.ServiceLifetime));
}
else
{
services.Add(descriptor);
}
}
}
var container = services.Build();
DependencyResolver.SetDependencyResolver(container);
return(container);
}