/// <summary>
/// The create instance.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
/// <param name="type">
/// The type.
/// </param>
/// <param name="nonPublic">
/// The non public.
/// </param>
/// <returns>
/// The create instance.
/// </returns>
/// <exception cref="ArgumentNullException">
/// </exception>
/// <exception cref="ArgumentNullException">
/// </exception>
public static object CreateInstance(this IComponentContext context, Type type, bool nonPublic)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
object res;
if (context.TryResolve(type, out res))
{
return(res);
}
var a = new ReflectionActivator(
type,
new BindingFlagsConstructorFinder(nonPublic ? BindingFlags.NonPublic : BindingFlags.Public),
new MostParametersConstructorSelector(),
new Parameter[] { },
new Parameter[] { });
return(a.ActivateInstance(context, new Parameter[] { }));
}
/// <summary>
/// Registers individual configured modules into a container builder.
/// </summary>
/// <param name="builder">
/// The <see cref="Autofac.ContainerBuilder"/> that should receive the configured registrations.
/// </param>
/// <param name="configurationSection">
/// The <see cref="Autofac.Configuration.SectionHandler"/> containing the configured registrations.
/// </param>
/// <exception cref="System.ArgumentNullException">
/// Thrown if <paramref name="builder"/> or <paramref name="configurationSection"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="System.Configuration.ConfigurationErrorsException">
/// Thrown if there is any issue in parsing the module configuration into registrations.
/// </exception>
/// <remarks>
/// <para>
/// This is where the individually configured component registrations get added to the <paramref name="builder" />.
/// The <see cref="Autofac.Configuration.SectionHandler.Modules"/> collection from the <paramref name="configurationSection" />
/// get processed into individual modules which are instantiated and activated inside the <paramref name="builder" />.
/// </para>
/// </remarks>
protected virtual void RegisterConfiguredModules(ContainerBuilder builder, SectionHandler configurationSection)
{
if (builder == null)
{
throw new ArgumentNullException("builder");
}
if (configurationSection == null)
{
throw new ArgumentNullException("configurationSection");
}
foreach (ModuleElement moduleElement in configurationSection.Modules)
{
var moduleType = this.LoadType(moduleElement.Type, configurationSection.DefaultAssembly);
IModule module = null;
using (var moduleActivator = new ReflectionActivator(
moduleType,
new DefaultConstructorFinder(),
new MostParametersConstructorSelector(),
moduleElement.Parameters.ToParameters(),
moduleElement.Properties.ToParameters()))
{
module = (IModule)moduleActivator.ActivateInstance(new ContainerBuilder().Build(), Enumerable.Empty <Parameter>());
}
builder.RegisterModule(module);
}
}
public virtual void RegisterConfiguredModules(ContainerBuilder builder, IConfiguration configuration)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
var defaultAssembly = configuration.DefaultAssembly();
foreach (var moduleElement in configuration.GetSection("modules").GetChildren())
{
var moduleTypeName = moduleElement["type"];
var moduleType = GetType(moduleTypeName, defaultAssembly);
if (moduleType == null)
{
// Log moduleTypeName
Console.WriteLine($"{moduleTypeName} module not found");
continue;
}
var module = (IModule)null;
using (var moduleActivator = new ReflectionActivator(
moduleType,
new DefaultConstructorFinder(),
new MostParametersConstructorSelector(),
moduleElement.GetParameters("parameters"),
moduleElement.GetProperties("properties")))
{
module = (IModule)moduleActivator.ActivateInstance(new ContainerBuilder().Build(), Enumerable.Empty <Parameter>());
}
builder.RegisterModule(module);
}
}
protected static void CreateClassProxy(IInterceptor[] interceptors, ActivatingEventArgs <object> e, Type type, object instance,
Type[] proxiedInterfaces)
{
// Ensure we don't try to proxy anything that can't be proxied
if (type.IsSealed)
{
return;
}
var targetType = type;
// Special handling for nested proxies...
if (ProxyUtil.IsProxy(instance))
{
OverrideProxyInterceptors(interceptors, instance);
}
else
{
var proxyType = ProxyGenerator.ProxyBuilder.CreateClassProxyType(targetType, proxiedInterfaces,
ProxyGenerationOptions.Default);
var activator = new ReflectionActivator(proxyType,
new DefaultConstructorFinder(),
new MostParametersConstructorSelector(),
GetConfiguredParams(ProxyGenerationOptions.Default, interceptors),
Enumerable.Empty <Parameter>());
e.ReplaceInstance(activator.ActivateInstance(e.Context, e.Parameters));
// Dispose of the old instance, if necessary
var oldInstance = instance as IDisposable;
oldInstance?.Dispose();
}
}
/// <summary>
/// Registers individual configured modules into a container builder.
/// </summary>
/// <param name="builder">
/// The <see cref="Autofac.ContainerBuilder"/> that should receive the configured registrations.
/// </param>
/// <param name="configuration">
/// The <see cref="IConfiguration"/> containing the configured registrations.
/// </param>
/// <exception cref="System.ArgumentNullException">
/// Thrown if <paramref name="builder"/> or <paramref name="configuration"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="System.InvalidOperationException">
/// Thrown if there is any issue in parsing the module configuration into registrations.
/// </exception>
/// <remarks>
/// <para>
/// This is where the individually configured component registrations get added to the <paramref name="builder"/>.
/// The <c>modules</c> collection from the <paramref name="configuration"/>
/// get processed into individual modules which are instantiated and activated inside the <paramref name="builder"/>.
/// </para>
/// </remarks>
public virtual void RegisterConfiguredModules(ContainerBuilder builder, IConfiguration configuration)
{
if (builder == null)
{
throw new ArgumentNullException("builder");
}
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
var defaultAssembly = configuration.DefaultAssembly();
foreach (var moduleElement in configuration.GetConfigurationSection("modules").GetConfigurationSections().Select(kvp => kvp.Value))
{
var moduleType = moduleElement.GetType("type", defaultAssembly);
var module = (IModule)null;
using (var moduleActivator = new ReflectionActivator(
moduleType,
new DefaultConstructorFinder(),
new MostParametersConstructorSelector(),
moduleElement.GetParameters("parameters"),
moduleElement.GetProperties("properties")))
{
module = (IModule)moduleActivator.ActivateInstance(new ContainerBuilder().Build(), Enumerable.Empty <Parameter>());
}
builder.RegisterModule(module);
}
}
private void RegisterConfiguredModule(ContainerBuilder builder, SectionHandler configurationSection, ModuleElement moduleElement)
{
try
{
var moduleType = this.LoadType(moduleElement.Type, configurationSection.DefaultAssembly);
IModule module = null;
IEnumerable <Parameter> parameters = moduleElement.Parameters.ToParameters().Select(p => new LazyParameter(p));
IEnumerable <Parameter> properties = moduleElement.Properties.ToParameters().Select(p => new LazyParameter(p));
using (var moduleActivator = new ReflectionActivator(
moduleType,
new DefaultConstructorFinder(),
new MostParametersConstructorSelector(),
parameters,
properties))
{
module = (IModule)moduleActivator.ActivateInstance(new ContainerBuilder().Build(), Enumerable.Empty <Parameter>());
}
builder.RegisterModule(module);
}
catch (Exception)
{
// log it
throw;
}
}
private static void ComponentRegistration_Activating(object sender, ActivatingEventArgs <object> e)
{
if (e.Instance == null || e.Instance.IsProxy())
{
return;
}
if (!(e.Component.Activator is ReflectionActivator ||
e.Component.Activator is DelegateActivator ||
e.Component.Activator is InstanceActivator))
{
return;
}
var limitType = e.Instance.GetType();
if (!limitType.GetTypeInfo().CanInherited())
{
return;
}
if (excepts.Any(x => limitType.Name.Matches(x)) || excepts.Any(x => limitType.Namespace.Matches(x)))
{
return;
}
var services = e.Component.Services.Select(x => ((IServiceWithType)x).ServiceType).ToList();
if (!services.All(x => x.GetTypeInfo().CanInherited()) || services.All(x => x.GetTypeInfo().IsNonAspect()))
{
return;
}
var aspectValidator = new AspectValidatorBuilder(e.Context.Resolve <IAspectConfiguration>()).Build();
if (services.All(x => !aspectValidator.Validate(x, true)) && !aspectValidator.Validate(limitType, false))
{
return;
}
var proxyTypeGenerator = e.Context.Resolve <IProxyTypeGenerator>();
Type proxyType; object instance;
var interfaceType = services.FirstOrDefault(x => x.GetTypeInfo().IsInterface);
if (interfaceType == null)
{
var baseType = services.FirstOrDefault(x => x.GetTypeInfo().IsClass) ?? limitType;
proxyType = proxyTypeGenerator.CreateClassProxyType(baseType, limitType);
var activator = new ReflectionActivator(proxyType, new DefaultConstructorFinder(type => type.GetTypeInfo().DeclaredConstructors.ToArray()), new MostParametersConstructorSelector(), new AParameter[0], new AParameter[0]);
instance = activator.ActivateInstance(e.Context, e.Parameters);
}
else
{
proxyType = proxyTypeGenerator.CreateInterfaceProxyType(interfaceType, limitType);
instance = Activator.CreateInstance(proxyType, new object[] { e.Context.Resolve <IAspectActivatorFactory>(), e.Instance });
}
var propertyInjector = e.Context.Resolve <IPropertyInjectorFactory>().Create(instance.GetType());
propertyInjector.Invoke(instance);
e.Instance = instance;
e.Component.RaiseActivating(e.Context, e.Parameters, ref instance);
}
private static bool ConstructorContainsLogger(ReflectionActivator reflectionActivator)
{
var constructors = reflectionActivator
.ConstructorFinder
.FindConstructors(reflectionActivator.LimitType);
return(constructors
.SelectMany(ctor => ctor.GetParameters())
.Any(parameterInfo => parameterInfo.ParameterType == typeof(ILog)));
}
private IComponentRegistration CreateClassInterceptorRegistration(IComponentRegistration registration)
{
if (registration == null)
{
throw new ArgumentNullException(nameof(registration));
}
var existingActivator = registration.Activator as ReflectionActivator;
var existingImplementationType = existingActivator.LimitType;
var options = new ProxyGenerationOptions(CreateProxyGenerationHook(existingImplementationType));
var newImplementationType = ProxyGenerator.ProxyBuilder.CreateClassProxyType(
existingImplementationType,
Array.Empty <Type>(),
options);
var newActivator = new ReflectionActivator(
newImplementationType,
existingActivator.ConstructorFinder,
existingActivator.ConstructorSelector,
Enumerable.Empty <Parameter>(),
Enumerable.Empty <Parameter>());
var newRegistration = new ComponentRegistration(Guid.NewGuid(), newActivator, registration.Lifetime, registration.Sharing, registration.Ownership, registration.Services, registration.Metadata, registration);
newRegistration.Preparing += (sender, args) =>
{
var proxyParameters = new List <Parameter>();
int index = 0;
if (options.HasMixins)
{
foreach (var mixin in options.MixinData.Mixins)
{
proxyParameters.Add(new PositionalParameter(index++, mixin));
}
}
var interceptors = GetInterceptorServices(args.Component)
.Select(s => args.Context.ResolveService(s))
.Cast <Castle.DynamicProxy.IInterceptor>()
.ToArray();
proxyParameters.Add(new PositionalParameter(index++, interceptors));
if (options.Selector != null)
{
proxyParameters.Add(new PositionalParameter(index, options.Selector));
}
args.Parameters = proxyParameters.Concat(args.Parameters).ToArray();
};
return(newRegistration);
}
static ConstructorInfo[] GetConstructorsSafe(ReflectionActivator ra)
{
// As of Autofac v4.7.0 "FindConstructors" will throw "NoConstructorsFoundException" instead of returning an empty array
// See: https://github.com/autofac/Autofac/pull/895 & https://github.com/autofac/Autofac/issues/733
ConstructorInfo[] ctors;
try
{
ctors = ra.ConstructorFinder.FindConstructors(ra.LimitType);
}
catch (NoConstructorsFoundException)
{
ctors = Array.Empty <ConstructorInfo>();
}
return(ctors);
}
public static void AsInterfacesProxy <TLimit, TConcreteReflectionActivatorData, TRegistrationStyle>(this IRegistrationBuilder <TLimit, TConcreteReflectionActivatorData, TRegistrationStyle> registration)
where TConcreteReflectionActivatorData : ConcreteReflectionActivatorData
{
if (registration == null)
{
throw new ArgumentNullException(nameof(registration));
}
var activatorData = registration.ActivatorData;
var interfaceTypes = registration.RegistrationData.Services.Select(s => s.GetServiceType()).Where(type => type.IsInterface).ToArray();
if (interfaceTypes.Length == 0)
{
return;
}
foreach (var interfaceType in interfaceTypes)
{
AutofacRealServiceProvider.MapActivatorData(interfaceType, activatorData);
}
registration.OnActivating(args =>
{
var parameters = args.Parameters.ToList();
parameters.Add(new ResolvedParameter((pi, ctx) => pi.ParameterType == typeof(IServiceProvider), (pi, ctx) => ctx.Resolve <IServiceProvider>()));
var proxyGenerator = args.Context.Resolve <IProxyGenerator>();
var proxyType = proxyGenerator.CreateClassProxyType(activatorData.ImplementationType, activatorData.ImplementationType);
var proxyActivator = new ReflectionActivator(proxyType, activatorData.ConstructorFinder,
activatorData.ConstructorSelector, EmptyArray <Parameter> .Value, activatorData.ConfiguredProperties);
var proxyValue = proxyActivator.ActivateInstance(args.Context, parameters);
args.ReplaceInstance(proxyValue);
});
}
DelegateActivator BuildActivator(IComponentRegistration cr, IServiceWithType swt)
{
var limitType = cr.Activator.LimitType;
var actualDecorators = decorators
.Where(d => d.Filter != null ? d.Filter(limitType) : true)
.Select(d => new { Type = d.Type, Parameters = d.ParamsGetter != null ? d.ParamsGetter(limitType) : Enumerable.Empty <Parameter>() })
.ToArray();
return(new DelegateActivator(cr.Activator.LimitType, (ctx, p) =>
{
var typeArgs = swt.ServiceType.GetGenericArguments();
var service = ctx.ResolveKeyed(fromKey, swt.ServiceType);
foreach (var decorator in actualDecorators)
{
var decoratorType = decorator.Type.MakeGenericType(typeArgs);
var @params = decorator.Parameters.Concat(new[] { new TypedParameter(swt.ServiceType, service) });
var activator = new ReflectionActivator(decoratorType, new DefaultConstructorFinder(), new MostParametersConstructorSelector(),
@params, Enumerable.Empty <Parameter>());
service = activator.ActivateInstance(ctx, @params);
}
return service;
}));
}
/// <summary>
/// Override to add registrations to the container.
/// </summary>
/// <param name="builder">The builder.</param>
protected override void Load(ContainerBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException("builder");
}
Assembly defaultAssembly = null;
if (!string.IsNullOrEmpty(_sectionHandler.DefaultAssembly))
{
defaultAssembly = Assembly.Load(_sectionHandler.DefaultAssembly);
}
foreach (ModuleElement moduleElement in _sectionHandler.Modules)
{
var moduleType = LoadType(moduleElement.Type, defaultAssembly);
var moduleActivator = new ReflectionActivator(
moduleType,
new BindingFlagsConstructorFinder(BindingFlags.Public),
new MostParametersConstructorSelector(),
moduleElement.Parameters.ToParameters(),
moduleElement.Properties.ToParameters());
var module = (IModule)moduleActivator.ActivateInstance(Container.Empty, Enumerable.Empty <Parameter>());
builder.RegisterModule(module);
}
foreach (ComponentElement component in _sectionHandler.Components)
{
var registrar = builder.RegisterType(LoadType(component.Type, defaultAssembly));
IList <Service> services = new List <Service>();
if (!string.IsNullOrEmpty(component.Service))
{
var serviceType = LoadType(component.Service, defaultAssembly);
if (!string.IsNullOrEmpty(component.Name))
{
services.Add(new KeyedService(component.Name, serviceType));
}
else
{
services.Add(new TypedService(serviceType));
}
}
else
{
if (!string.IsNullOrEmpty(component.Name))
{
throw new ConfigurationErrorsException(string.Format(
ConfigurationSettingsReaderResources.ServiceTypeMustBeSpecified, component.Name));
}
}
foreach (ServiceElement service in component.Services)
{
var serviceType = LoadType(service.Type, defaultAssembly);
if (!string.IsNullOrEmpty(service.Name))
{
services.Add(new KeyedService(service.Name, serviceType));
}
else
{
services.Add(new TypedService(serviceType));
}
}
foreach (var service in services)
{
registrar.As(service);
}
foreach (var param in component.Parameters.ToParameters())
{
registrar.WithParameter(param);
}
foreach (var prop in component.Properties.ToParameters())
{
registrar.WithProperty(prop);
}
foreach (var ep in component.Metadata)
{
registrar.WithMetadata(
ep.Name, TypeManipulation.ChangeToCompatibleType(ep.Value, Type.GetType(ep.Type)));
}
if (!string.IsNullOrEmpty(component.MemberOf))
{
registrar.MemberOf(component.MemberOf);
}
SetScope(component, registrar);
SetOwnership(component, registrar);
SetInjectProperties(component, registrar);
}
foreach (FileElement file in _sectionHandler.Files)
{
var section = DefaultSectionName;
if (!string.IsNullOrEmpty(file.Section))
{
section = file.Section;
}
var reader = new ConfigurationSettingsReader(section, file.Name);
builder.RegisterModule(reader);
}
}
static bool AnyConstructorHasLoggerDependency(ReflectionActivator activator) => activator .ConstructorFinder.FindConstructors(activator.LimitType) .SelectMany(constructor => constructor.GetParameters().Select(_ => _.ParameterType)) .Any(parameterType => parameterType == typeof(ILogger));