RegisterCollection <T>(ContainerBuilder builder, string collectionName, Type elementType)
{
if (builder == null)
{
throw new ArgumentNullException("builder");
}
if (elementType == null)
{
throw new ArgumentNullException("elementType");
}
Enforce.ArgumentNotNullOrEmpty(collectionName, "collectionName");
var arrayType = elementType.MakeArrayType();
var ts = new TypedService(elementType);
var activator = new DelegateActivator(arrayType, (c, p) =>
{
var elements = GetElementRegistrations(collectionName, c.ComponentRegistry);
var items = elements.Select(e => c.ResolveComponent(ts, e, p)).ToArray();
var result = Array.CreateInstance(elementType, items.Length);
items.CopyTo(result, 0);
return(result);
});
var rb = new RegistrationBuilder <T[], SimpleActivatorData, SingleRegistrationStyle>(
new TypedService(typeof(T[])),
new SimpleActivatorData(activator),
new SingleRegistrationStyle());
builder.RegisterCallback(cr => RegistrationBuilder.RegisterSingleComponent(cr, rb));
return(rb);
}
/// <summary>
/// Registers aggregation decorator (decorator that will broadcast all calls to all decorated instances)
/// for the services of type <typeparamref name="TService" />.
/// </summary>
/// <typeparam name="TService">Type of the decorated services.</typeparam>
/// <param name="builder">Container builder.</param>
/// <param name="decoratorFactory">Factory delegate that can create new instances of the aggregate decorator.</param>
/// <returns>Registration builder to continue the registration.</returns>
public static IRegistrationBuilder <TService, SimpleActivatorData, SingleRegistrationStyle> RegisterAggregationDecorator <TService>(
this ContainerBuilder builder, Func <IComponentContext, IEnumerable <TService>, TService> decoratorFactory)
{
Guard.NotNull("builder", builder);
Guard.NotNull("decoratorFactory", decoratorFactory);
var originalKey = Guid.NewGuid();
var registrationBuilder = RegistrationBuilder.ForDelegate((c, p) => decoratorFactory(c, c.ResolveKeyed <IEnumerable <TService> >(originalKey))).As <TService>();
builder.RegisterCallback(cr =>
{
Guard.NotNull("componentRegistry", cr);
var service = new TypedService(typeof(TService));
var originalRegistrations = cr.RegistrationsFor(service);
// Register original component as keyed
foreach (var originalRegistration in originalRegistrations)
{
cr.Register(RegistrationBuilder.CreateRegistration(
Guid.NewGuid(),
CopyRegistrationData(originalRegistration),
originalRegistration.Activator,
new[] { new KeyedService(originalKey, typeof(TService)) }));
}
// Override default registration with decorator
RegistrationBuilder.RegisterSingleComponent <TService, SimpleActivatorData, SingleRegistrationStyle>(cr, registrationBuilder);
});
return(registrationBuilder);
}
private static void RegisterConfiguration(ContainerBuilder builder, AutoConfigurationDetail autoConfigurationDetail)
{
//注册为工厂
foreach (var beanMethod in autoConfigurationDetail.BeanMethodInfoList)
{
if (!beanMethod.Item2.IsVirtual)
{
throw new InvalidOperationException(
$"The Configuration class `{autoConfigurationDetail.AutoConfigurationClassType.FullName}` method `{beanMethod.Item2.Name}` must be virtual!");
}
if (!ProxyUtil.IsAccessible(beanMethod.Item2.ReturnType))
{
throw new InvalidOperationException(
$"The Configuration class `{autoConfigurationDetail.AutoConfigurationClassType.FullName}` method `{beanMethod.Item2.Name}` returnType is not accessible!");
}
if (beanMethod.Item2.ReturnType.IsValueType || beanMethod.Item2.ReturnType.IsEnum)
{
throw new InvalidOperationException(
$"The Configuration class `{autoConfigurationDetail.AutoConfigurationClassType.FullName}` method `{beanMethod.Item2.Name}` returnType is invalid!");
}
//包装这个方法成功工厂
//先拿到AutoConfiguration class的实例
//注册一个方法到容器 拿到并传入IComponentContext
builder.RegisterCallback(cr =>
{
var instanceType = beanMethod.Item3;//返回类型
var rb = RegistrationBuilder.ForDelegate(instanceType, ((context, parameters) =>
{
var autoConfigurationInstance = context.Resolve(autoConfigurationDetail.AutoConfigurationClassType);
var instance = AutoConfigurationHelper.InvokeInstanceMethod(context, autoConfigurationDetail, autoConfigurationInstance, beanMethod.Item2);
if (typeof(Task).IsAssignableFrom(instance.GetType()))
{
return(typeof(Task <>).MakeGenericType(instanceType).GetProperty("Result").GetValue(instance));
}
return(instance);
}));
if (!string.IsNullOrEmpty(beanMethod.Item1.Key))
{
rb.Keyed(beanMethod.Item1.Key, instanceType).Named("`1System.Collections.Generic.IEnumerable`1" + instanceType.FullName, instanceType);
}
else
{
rb.As(instanceType).Named("`1System.Collections.Generic.IEnumerable`1" + instanceType.FullName, instanceType);
}
rb.SingleInstance();
RegistrationBuilder.RegisterSingleComponent(cr, rb);
});
}
}
internal static IRegistrationBuilder <TLimit, GeneratedFactoryActivatorData, SingleRegistrationStyle> RegisterGeneratedFactory <TLimit>(ContainerBuilder builder, Type delegateType, Service service)
{
GeneratedFactoryActivatorData activatorData = new GeneratedFactoryActivatorData(delegateType, service);
RegistrationBuilder <TLimit, GeneratedFactoryActivatorData, SingleRegistrationStyle> rb = new RegistrationBuilder <TLimit, GeneratedFactoryActivatorData, SingleRegistrationStyle>(new TypedService(delegateType), activatorData, new SingleRegistrationStyle());
builder.RegisterCallback(delegate(IComponentRegistry cr) {
RegistrationBuilder.RegisterSingleComponent <TLimit, GeneratedFactoryActivatorData, SingleRegistrationStyle>(cr, rb);
});
return(rb.InstancePerLifetimeScope());
}
RegisterInstance <T>(this ContainerBuilder builder, T instance)
where T : class
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (instance == null)
{
throw new ArgumentNullException(nameof(instance));
}
var activator = new ProvidedInstanceActivator(instance);
var rb = new RegistrationBuilder <T, SimpleActivatorData, SingleRegistrationStyle>(
new TypedService(typeof(T)),
new SimpleActivatorData(activator),
new SingleRegistrationStyle());
rb.SingleInstance();
rb.RegistrationData.DeferredCallback = builder.RegisterCallback(cr =>
{
if (!(rb.RegistrationData.Lifetime is RootScopeLifetime) ||
rb.RegistrationData.Sharing != InstanceSharing.Shared)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, RegistrationExtensionsResources.InstanceRegistrationsAreSingleInstanceOnly, instance));
}
activator.DisposeInstance = rb.RegistrationData.Ownership == InstanceOwnership.OwnedByLifetimeScope;
// https://github.com/autofac/Autofac/issues/1102
// Single instance registrations with any custom activation phases (i.e. activation handlers) need to be auto-activated,
// so that other behaviour (such as OnRelease) that expects 'normal' object lifetime behaviour works as expected.
if (rb.ResolvePipeline.Middleware.Any(s => s.Phase == PipelinePhase.Activation))
{
var autoStartService = rb.RegistrationData.Services.First();
var activationRegistration = new RegistrationBuilder <T, SimpleActivatorData, SingleRegistrationStyle>(
new AutoActivateService(),
new SimpleActivatorData(new DelegateActivator(typeof(T), (c, p) => c.ResolveService(autoStartService))),
new SingleRegistrationStyle());
RegistrationBuilder.RegisterSingleComponent(cr, activationRegistration);
}
RegistrationBuilder.RegisterSingleComponent(cr, rb);
});
return(rb);
}
public static IRegistrationBuilder <TImplementor, ConcreteReflectionActivatorData, SingleRegistrationStyle> RegisterType <TImplementor>(this ContainerBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException("builder");
}
IRegistrationBuilder <TImplementor, ConcreteReflectionActivatorData, SingleRegistrationStyle> rb = RegistrationBuilder.ForType <TImplementor>();
builder.RegisterCallback(delegate(IComponentRegistry cr) {
RegistrationBuilder.RegisterSingleComponent <TImplementor, ConcreteReflectionActivatorData, SingleRegistrationStyle>(cr, rb);
});
return(rb);
}
RegisterGeneratedFactory <TLimit>(ContainerBuilder builder, Type delegateType, Service service)
{
var activatorData = new GeneratedFactoryActivatorData(delegateType, service);
var rb = new RegistrationBuilder <TLimit, GeneratedFactoryActivatorData, SingleRegistrationStyle>(
new TypedService(delegateType),
activatorData,
new SingleRegistrationStyle());
builder.RegisterCallback(cr => RegistrationBuilder.RegisterSingleComponent(cr, rb));
return(rb.InstancePerLifetimeScope());
}
public static IRegistrationBuilder <T, SimpleActivatorData, SingleRegistrationStyle> RegisterGlobalService <T>(this ContainerBuilder cb, Func <IComponentContext, T> factory)
{
var rb = RegistrationBuilder.ForDelegate((c, p) => factory(c));
rb.WithMetadata("ctm.registeredonce", rb.ActivatorData.Activator.LimitType);
cb.RegisterCallback(cr =>
{
if (!AlreadyRegistered(rb, cr))
{
RegistrationBuilder.RegisterSingleComponent(cr, rb);
}
});;
return(rb);
}
RegisterType <[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] TImplementer>(this ContainerBuilder builder)
where TImplementer : notnull
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
var rb = RegistrationBuilder.ForType <TImplementer>();
rb.RegistrationData.DeferredCallback = builder.RegisterCallback(cr => RegistrationBuilder.RegisterSingleComponent(cr, rb));
return(rb);
}
static void ScanTypes(IEnumerable <Type> types, IComponentRegistry cr, IRegistrationBuilder <object, ScanningActivatorData, DynamicRegistrationStyle> rb)
{
rb.ActivatorData.Filters.Add(t =>
rb.RegistrationData.Services.OfType <IServiceWithType>().All(swt =>
swt.ServiceType.IsAssignableFrom(t)));
#if !ASPNETCORE50
foreach (var t in types
.Where(t =>
t.IsClass &&
!t.IsAbstract &&
!t.IsGenericTypeDefinition &&
!t.IsDelegate() &&
rb.ActivatorData.Filters.All(p => p(t))))
#else
foreach (var t in types
.Where(t =>
t.GetTypeInfo().IsClass&&
!t.GetTypeInfo().IsAbstract&&
!t.GetTypeInfo().IsGenericTypeDefinition&&
!t.IsDelegate() &&
rb.ActivatorData.Filters.All(p => p(t))))
#endif
{
var scanned = RegistrationBuilder.ForType(t)
.FindConstructorsWith(rb.ActivatorData.ConstructorFinder)
.UsingConstructor(rb.ActivatorData.ConstructorSelector)
.WithParameters(rb.ActivatorData.ConfiguredParameters)
.WithProperties(rb.ActivatorData.ConfiguredProperties);
scanned.RegistrationData.CopyFrom(rb.RegistrationData, false);
foreach (var action in rb.ActivatorData.ConfigurationActions)
{
action(t, scanned);
}
if (scanned.RegistrationData.Services.Any())
{
RegistrationBuilder.RegisterSingleComponent(cr, scanned);
}
}
foreach (var postScanningCallback in rb.ActivatorData.PostScanningCallbacks)
{
postScanningCallback(cr);
}
}
Except<T>(
this IRegistrationBuilder<object, ScanningActivatorData, DynamicRegistrationStyle> registration,
Action<IRegistrationBuilder<T, ConcreteReflectionActivatorData, SingleRegistrationStyle>> customizedRegistration)
where T : notnull
{
var result = registration.Except<T>();
result.ActivatorData.PostScanningCallbacks.Add(cr =>
{
var rb = RegistrationBuilder.ForType<T>();
customizedRegistration(rb);
RegistrationBuilder.RegisterSingleComponent(cr, rb);
});
return result;
}
public static IRegistrationBuilder <object, SimpleActivatorData, SingleRegistrationStyle> RegisterInstance(IComponentRegistry cr, Type returnType, object instance, string key)
{
if (instance == null)
{
throw new ArgumentNullException(nameof(instance));
}
var activator = new ProvidedInstanceActivator(instance);
var instanceType = instance.GetType();
var rb = RegistrationBuilder.ForDelegate(instanceType, ((context, parameters) => instance));
if (returnType != instanceType)
{
if (!string.IsNullOrEmpty(key))
{
rb.Keyed(key, returnType).Named("`1System.Collections.Generic.IEnumerable`1" + returnType.FullName, returnType);
}
else
{
rb.As(returnType).Named("`1System.Collections.Generic.IEnumerable`1" + returnType.FullName, returnType);
}
}
else
{
if (!string.IsNullOrEmpty(key))
{
rb.Keyed(key, instanceType).Named("`1System.Collections.Generic.IEnumerable`1" + instanceType.FullName, instanceType);
}
else
{
rb.As(instanceType).Named("`1System.Collections.Generic.IEnumerable`1" + instanceType.FullName, instanceType);
}
}
rb.SingleInstance();
if (!(rb.RegistrationData.Lifetime is RootScopeLifetime) ||
rb.RegistrationData.Sharing != InstanceSharing.Shared)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "The instance registration `{0}` can support SingleInstance() sharing only", instance));
}
activator.DisposeInstance = rb.RegistrationData.Ownership == InstanceOwnership.OwnedByLifetimeScope;
RegistrationBuilder.RegisterSingleComponent(cr, rb);
return(rb);
}
public static IRegistrationBuilder <T, SimpleActivatorData, SingleRegistrationStyle> Register <T>(this ContainerBuilder builder, Func <IComponentContext, IEnumerable <Parameter>, T> @delegate)
{
if (builder == null)
{
throw new ArgumentNullException("builder");
}
if (@delegate == null)
{
throw new ArgumentNullException("delegate");
}
IRegistrationBuilder <T, SimpleActivatorData, SingleRegistrationStyle> rb = RegistrationBuilder.ForDelegate <T>(@delegate);
builder.RegisterCallback(delegate(IComponentRegistry cr) {
RegistrationBuilder.RegisterSingleComponent <T, SimpleActivatorData, SingleRegistrationStyle>(cr, rb);
});
return(rb);
}
private static void ScanTypes(IEnumerable <Type> types, IComponentRegistryBuilder cr, IRegistrationBuilder <object, ScanningActivatorData, DynamicRegistrationStyle> rb)
{
var closedTypes = types.Where(t => !t.IsGenericTypeDefinition)
.CanBeRegistered(rb.ActivatorData);
rb.ActivatorData.Filters.Add(t =>
rb.RegistrationData.Services.OfType <IServiceWithType>().All(swt =>
swt.ServiceType.IsAssignableFrom(t)));
Func <Type, IRegistrationBuilder <object, ConcreteReflectionActivatorData, SingleRegistrationStyle> > scannedConstructor =
(type) => RegistrationBuilder.ForType(type);
Action <IComponentRegistryBuilder, IRegistrationBuilder <object, ConcreteReflectionActivatorData, SingleRegistrationStyle> > register =
(cr, scanned) => RegistrationBuilder.RegisterSingleComponent(cr, scanned);
ScanTypesTemplate(closedTypes, cr, rb, scannedConstructor, register);
}
private static void ScanTypes(IEnumerable <Type> types, IComponentRegistryBuilder cr, IRegistrationBuilder <object, ScanningActivatorData, DynamicRegistrationStyle> rb)
{
rb.ActivatorData.Filters.Add(t =>
rb.RegistrationData.Services.OfType <IServiceWithType>().All(swt =>
swt.ServiceType.IsAssignableFrom(t)));
// Issue #897: For back compat reasons we can't filter out
// non-public types here. Folks use assembly scanning on their
// own stuff, so encapsulation is a tricky thing to manage.
// If people want only public types, a LINQ Where clause can be used.
foreach (var t in types
.Where(t =>
t.IsClass &&
!t.IsAbstract &&
!t.IsGenericTypeDefinition &&
!t.IsDelegate() &&
rb.ActivatorData.Filters.All(p => p(t)) &&
!t.IsCompilerGenerated()))
{
var scanned = RegistrationBuilder.ForType(t)
.FindConstructorsWith(rb.ActivatorData.ConstructorFinder)
.UsingConstructor(rb.ActivatorData.ConstructorSelector)
.WithParameters(rb.ActivatorData.ConfiguredParameters)
.WithProperties(rb.ActivatorData.ConfiguredProperties);
// Copy middleware from the scanning registration.
scanned.ResolvePipeline.UseRange(rb.ResolvePipeline.Middleware);
scanned.RegistrationData.CopyFrom(rb.RegistrationData, false);
foreach (var action in rb.ActivatorData.ConfigurationActions)
{
action(t, scanned);
}
if (scanned.RegistrationData.Services.Any())
{
RegistrationBuilder.RegisterSingleComponent(cr, scanned);
}
}
foreach (var postScanningCallback in rb.ActivatorData.PostScanningCallbacks)
{
postScanningCallback(cr);
}
}
RegisterType(this ContainerBuilder builder, Type implementationType)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (implementationType == null)
{
throw new ArgumentNullException(nameof(implementationType));
}
var rb = RegistrationBuilder.ForType(implementationType);
rb.RegistrationData.DeferredCallback = builder.RegisterCallback(cr => RegistrationBuilder.RegisterSingleComponent(cr, rb));
return(rb);
}
public static IRegistrationBuilder <object, ScanningActivatorData, DynamicRegistrationStyle> Except <T>(this IRegistrationBuilder <object, ScanningActivatorData, DynamicRegistrationStyle> registration, Action <IRegistrationBuilder <T, ConcreteReflectionActivatorData, SingleRegistrationStyle> > customisedRegistration)
{
var result = registration.Except <T>();
result.ActivatorData.PostScanningCallbacks.Add(cr =>
{
var rb = RegistrationBuilder.ForType <T>();
customisedRegistration(rb);
RegistrationBuilder.RegisterSingleComponent(cr, rb);
});
return(result);
//IRegistrationBuilder<object, ScanningActivatorData, DynamicRegistrationStyle> builder = registration.Except<T>();
//builder.ActivatorData.PostScanningCallbacks.Add(delegate (IComponentRegistry cr) {
// IRegistrationBuilder<T, ConcreteReflectionActivatorData, SingleRegistrationStyle> builder = RegistrationBuilder.ForType<T>();
// customisedRegistration(builder);
// RegistrationBuilder.RegisterSingleComponent<T, ConcreteReflectionActivatorData, SingleRegistrationStyle>(cr, builder);
//});
//return builder;
}
Register <T>(
this ContainerBuilder builder,
Func <IComponentContext, IEnumerable <Parameter>, T> @delegate)
where T : notnull
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (@delegate == null)
{
throw new ArgumentNullException(nameof(@delegate));
}
var rb = RegistrationBuilder.ForDelegate(@delegate);
rb.RegistrationData.DeferredCallback = builder.RegisterCallback(cr => RegistrationBuilder.RegisterSingleComponent(cr, rb));
return(rb);
}
RegisterDynamically(
this ContainerBuilder builder,
Type typeLimit,
Func <IComponentContext, object> @delegate)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (@delegate == null)
{
throw new ArgumentNullException(nameof(@delegate));
}
Func <IComponentContext, IEnumerable <AF.Core.Parameter>, object> @del = (c, p) => @delegate(c);
var rb = RegistrationBuilder.ForDelegate(typeLimit, @del);
rb.RegistrationData.DeferredCallback = builder.RegisterCallback(cr => RegistrationBuilder.RegisterSingleComponent(cr, rb));
return(rb);
}
public static IRegistrationBuilder <T, SimpleActivatorData, SingleRegistrationStyle> RegisterInstance <T>(this ContainerBuilder builder, T instance) where T : class
{
if (builder == null)
{
throw new ArgumentNullException("builder");
}
if (instance == null)
{
throw new ArgumentNullException("instance");
}
ProvidedInstanceActivator activator = new ProvidedInstanceActivator(instance);
RegistrationBuilder <T, SimpleActivatorData, SingleRegistrationStyle> rb = new RegistrationBuilder <T, SimpleActivatorData, SingleRegistrationStyle>(new TypedService(typeof(T)), new SimpleActivatorData(activator), new SingleRegistrationStyle());
rb.SingleInstance();
builder.RegisterCallback(delegate(IComponentRegistry cr) {
if (!(rb.RegistrationData.Lifetime is RootScopeLifetime) || (rb.RegistrationData.Sharing != InstanceSharing.Shared))
{
throw new InvalidOperationException(string.Format(RegistrationExtensionsResources.InstanceRegistrationsAreSingleInstanceOnly, instance));
}
activator.DisposeInstance = rb.RegistrationData.Ownership == InstanceOwnership.OwnedByLifetimeScope;
RegistrationBuilder.RegisterSingleComponent <T, SimpleActivatorData, SingleRegistrationStyle>(cr, rb);
});
return(rb);
}
public static IRegistrationBuilder <T[], SimpleActivatorData, SingleRegistrationStyle> RegisterCollection <T>(ContainerBuilder builder, string collectionName, Type elementType)
{
if (builder == null)
{
throw new ArgumentNullException("builder");
}
if (elementType == null)
{
throw new ArgumentNullException("elementType");
}
Enforce.ArgumentNotNullOrEmpty(collectionName, "collectionName");
DelegateActivator activator = new DelegateActivator(elementType.MakeArrayType(), delegate(IComponentContext c, IEnumerable <Parameter> p) {
object[] objArray = (from e in GetElementRegistrations(collectionName, c.ComponentRegistry) select c.ResolveComponent(e, p)).ToArray <object>();
Array array = Array.CreateInstance(elementType, objArray.Length);
objArray.CopyTo(array, 0);
return(array);
});
RegistrationBuilder <T[], SimpleActivatorData, SingleRegistrationStyle> rb = new RegistrationBuilder <T[], SimpleActivatorData, SingleRegistrationStyle>(new TypedService(typeof(T[])), new SimpleActivatorData(activator), new SingleRegistrationStyle());
builder.RegisterCallback(delegate(IComponentRegistry cr) {
RegistrationBuilder.RegisterSingleComponent <T[], SimpleActivatorData, SingleRegistrationStyle>(cr, rb);
});
return(rb);
}
