protected void HandleDecoration( IRegistrationBuilder<object, IConcreteActivatorData, SingleRegistrationStyle> registration, bool hasDecorator) { if (hasDecorator) { registration.Named(ServiceType.FullName, ServiceType); } else { registration.As(ServiceType); } }
private static void SetLifetimeScope(ComponentCallModelEnum callModel, IRegistrationBuilder<object, ConcreteReflectionActivatorData, SingleRegistrationStyle> registrationBuilder) { switch (callModel) { case ComponentCallModelEnum.Singlecall: registrationBuilder.InstancePerDependency(); break; case ComponentCallModelEnum.Singleton: registrationBuilder.SingleInstance(); break; default: registrationBuilder.InstancePerLifetimeScope(); break; } }
public void Apply( IRegistrationBuilder<object, ConcreteReflectionActivatorData, SingleRegistrationStyle> registration, Type dependencyType) { if (registration == null) { throw new ArgumentNullException("registration"); } if (dependencyType == null) { throw new ArgumentNullException("dependencyType"); } registration.AsSelf(); }
public void Apply( IRegistrationBuilder<object, ConcreteReflectionActivatorData, SingleRegistrationStyle> registration, Type dependencyType) { if (registration == null) { throw new ArgumentNullException("registration"); } if (dependencyType == null) { throw new ArgumentNullException("dependencyType"); } foreach (var itf in dependencyType.GetInterfaces().Where(i => i.HasInterface(typeof(ITransientDependency)))) { registration.As(itf).InstancePerDependency(); } }
private static IRegistrationBuilder<object, IConcreteActivatorData, SingleRegistrationStyle> ApplyLifestyleSingle(IRegistrationBuilder<object, IConcreteActivatorData, SingleRegistrationStyle> registration, Lifestyle lifestyle) { if (lifestyle.Name == Lifestyle.Singleton.Name) return registration.SingleInstance(); if (lifestyle.Name == Lifestyle.Transient.Name) return registration.InstancePerDependency(); if (lifestyle.Name == Lifestyle.PerWebRequest.Name) return registration.InstancePerMatchingLifetimeScope("httpRequest"); if (lifestyle.Name == Lifestyle.Unmanaged.Name) return registration.ExternallyOwned(); if (lifestyle.Name == Lifestyle.Default.Name) return registration.SingleInstance(); if (lifestyle.Name == Lifestyle.ProviderDefault.Name) return registration; throw new ArgumentException(string.Format("Unknown lifestyle : {0}", lifestyle), "lifestyle"); }
private static void RegisterPooled <TLimit, TActivatorData, TSingleRegistrationStyle>( IRegistrationBuilder <TLimit, TActivatorData, TSingleRegistrationStyle> registration, IPooledRegistrationPolicy <TLimit> registrationPolicy, object[]?tags) where TSingleRegistrationStyle : SingleRegistrationStyle where TActivatorData : IConcreteActivatorData where TLimit : class { if (registration == null) { throw new ArgumentNullException(nameof(registration)); } // Mark the lifetime appropriately. var regData = registration.RegistrationData; regData.Lifetime = new PooledLifetime(); regData.Sharing = InstanceSharing.None; var callback = regData.DeferredCallback; if (callback is null) { throw new NotSupportedException(RegistrationExtensionsResources.RequiresCallbackContainer); } if (registration.ActivatorData.Activator is ProvidedInstanceActivator) { // Can't use provided instance activators with pooling (because it would try to repeatedly activate). throw new NotSupportedException(RegistrationExtensionsResources.CannotUseProvidedInstances); } var original = callback.Callback; Action <IComponentRegistryBuilder> newCallback = registry => { // Only do the additional registrations if we are still using a PooledLifetime. if (!(regData.Lifetime is PooledLifetime)) { original(registry); return; } var pooledInstanceService = new UniqueService(); var instanceActivator = registration.ActivatorData.Activator; if (registration.ResolvePipeline.Middleware.Any(c => c is CoreEventMiddleware ev && ev.EventType == ResolveEventType.OnRelease)) { // OnRelease shouldn't be used with pooled instances, because if a policy chooses not to return them to the pool, // the Disposal will be fired, not the OnRelease call; this means that OnRelease wouldn't fire until the container is disposed, // which is not what we want. throw new NotSupportedException(RegistrationExtensionsResources.OnReleaseNotSupported); } // First, we going to create a pooled instance activator, that will be resolved when we want to // **actually** resolve a new instance (during 'Create'). // The instances themselves are owned by the pool, and will be disposed when the pool disposes // (or when the instance is not returned to the pool). var pooledInstanceRegistration = new ComponentRegistration( Guid.NewGuid(), instanceActivator, RootScopeLifetime.Instance, InstanceSharing.None, InstanceOwnership.ExternallyOwned, registration.ResolvePipeline, new[] { pooledInstanceService }, new Dictionary <string, object?>()); registry.Register(pooledInstanceRegistration); var poolService = new PoolService(pooledInstanceRegistration); var poolRegistration = new ComponentRegistration( Guid.NewGuid(), new PoolActivator <TLimit>(pooledInstanceService, registrationPolicy), RootScopeLifetime.Instance, InstanceSharing.Shared, InstanceOwnership.OwnedByLifetimeScope, new[] { poolService }, new Dictionary <string, object?>()); registry.Register(poolRegistration); var pooledGetLifetime = tags is null ? CurrentScopeLifetime.Instance : new MatchingScopeLifetime(tags); // Next, create a new registration with a custom activator, that copies metadata and services from // the original registration. This registration will access the pool and return an instance from it. var poolGetRegistration = new ComponentRegistration( Guid.NewGuid(), new PoolGetActivator <TLimit>(poolService, registrationPolicy), pooledGetLifetime, InstanceSharing.Shared, InstanceOwnership.OwnedByLifetimeScope, regData.Services, regData.Metadata); registry.Register(poolGetRegistration); // Finally, add a service pipeline stage to just before the sharing middleware, for each supported service, to extract the pooled instance from the pool instance container. foreach (var srv in regData.Services) { registry.RegisterServiceMiddleware(srv, new PooledInstanceUnpackMiddleware <TLimit>(), MiddlewareInsertionMode.StartOfPhase); } }; callback.Callback = newCallback; }
WithOrder <TLimit, TActivatorData, TRegistrationStyle>( this IRegistrationBuilder <TLimit, TActivatorData, TRegistrationStyle> registrationBuilder) => registrationBuilder.WithMetadata(OrderString, Interlocked.Increment(ref orderCounter));
protected void HandleDecoration( IRegistrationBuilder<object, ReflectionActivatorData, DynamicRegistrationStyle> registration, bool hasDecorator) { if (hasDecorator) { registration.Named(ServiceType.FullName, ServiceType); } else { registration.As(ServiceType); } }
public static IRegistrationBuilder <TLimit, TActivatorData, TSingleRegistrationStyle> MemberOf <TLimit, TActivatorData, TSingleRegistrationStyle>(IRegistrationBuilder <TLimit, TActivatorData, TSingleRegistrationStyle> registration, string collectionName) where TSingleRegistrationStyle : SingleRegistrationStyle { if (registration == null) { throw new ArgumentNullException("registration"); } Enforce.ArgumentNotNull(collectionName, "collectionName"); registration.OnRegistered <TLimit, TActivatorData, TSingleRegistrationStyle>(delegate(ComponentRegisteredEventArgs e) { IDictionary <string, object> metadata = e.ComponentRegistration.Metadata; if (metadata.ContainsKey("Autofac.CollectionRegistrationExtensions.MemberOf")) { metadata["Autofac.CollectionRegistrationExtensions.MemberOf"] = ((IEnumerable <string>)metadata["Autofac.CollectionRegistrationExtensions.MemberOf"]).Union <string>(new string[] { collectionName }); } else { metadata.Add("Autofac.CollectionRegistrationExtensions.MemberOf", new string[] { collectionName }); } }); return(registration); }
protected virtual void SetAutoActivate <TReflectionActivatorData, TSingleRegistrationStyle>(IRegistrationBuilder <object, TReflectionActivatorData, TSingleRegistrationStyle> registrar, string autoActivate) where TReflectionActivatorData : ReflectionActivatorData where TSingleRegistrationStyle : SingleRegistrationStyle { if (registrar == null) { throw new ArgumentNullException("registrar"); } if (string.IsNullOrWhiteSpace(autoActivate)) { return; } string key; switch (key = autoActivate.Trim().ToUpperInvariant()) { case "NO": case "N": case "FALSE": case "0": return; case "YES": case "Y": case "TRUE": case "1": RegistrationExtensions.AutoActivate <object, TReflectionActivatorData, TSingleRegistrationStyle>(registrar); return; } throw new ConfigurationErrorsException(string.Format(CultureInfo.CurrentCulture, ConfigurationSettingsReaderResources.UnrecognisedAutoActivate, new object[] { autoActivate })); }
/// <summary> /// 根据组件的生命周期定义注册组件 /// </summary> /// <param name="buidler">Autofac的IContainer对象</param> /// <param name="assemblies">注册的程序集</param> /// <returns>Autofac的注册构造器枚举</returns> public static IEnumerable <IRegistrationBuilder <object, Autofac.Features.Scanning.ScanningActivatorData, DynamicRegistrationStyle> > RegisterAssemblyTypesWithLiftTimeScope(this ContainerBuilder buidler, params Assembly[] assemblies) { IEnumerable <IRegistrationBuilder <object, Autofac.Features.Scanning.ScanningActivatorData, DynamicRegistrationStyle> > builders = new IRegistrationBuilder <object, Autofac.Features.Scanning.ScanningActivatorData, DynamicRegistrationStyle>[] { //瞬态 buidler.RegisterAssemblyTypes(assemblies).Where(m => ComponentRegistryAttribute.ValidateType(m, Lifetime.Transient)).InstancePerDependency(), //单例 buidler.RegisterAssemblyTypes(assemblies).Where(m => ComponentRegistryAttribute.ValidateType(m, Lifetime.Singleton)).SingleInstance(), //容器 buidler.RegisterAssemblyTypes(assemblies).Where(m => ComponentRegistryAttribute.ValidateType(m, Lifetime.Container)).InstancePerLifetimeScope(), }; return(builders); }
/// <summary> /// Enable interface interception on the target type. Interceptors will be determined /// via Intercept attributes on the class or interface, or added with InterceptedBy() calls. /// </summary> /// <typeparam name="TLimit">Registration limit type.</typeparam> /// <typeparam name="TActivatorData">Activator data type.</typeparam> /// <typeparam name="TSingleRegistrationStyle">Registration style.</typeparam> /// <param name="registration">Registration to apply interception to.</param> /// <returns>Registration builder allowing the registration to be configured.</returns> public static IRegistrationBuilder <TLimit, TActivatorData, TSingleRegistrationStyle> EnableInterfaceInterceptors <TLimit, TActivatorData, TSingleRegistrationStyle>( this IRegistrationBuilder <TLimit, TActivatorData, TSingleRegistrationStyle> registration) { return(EnableInterfaceInterceptors(registration, null)); }
/// <summary> /// Sets the auto activation mode for the component. /// </summary> /// <param name="component"> /// The configuration data containing the component. The <c>autoActivate</c> /// content will be read from this configuration object and used /// to determine auto activation status. /// </param> /// <param name="registrar"> /// The component registration on which auto activation mode is being set. /// </param> /// <remarks> /// <para> /// By default, this implementation understands <see langword="null"/>, empty, /// or <see langword="false"/> values (<c>false</c>, <c>0</c>, <c>no</c>) /// to mean "not auto-activated" and <see langword="true"/> /// values (<c>true</c>, <c>1</c>, <c>yes</c>) to mean "auto activation /// should occur." /// </para> /// <para> /// You may override this method to extend the available grammar for auto activation settings. /// </para> /// </remarks> /// <exception cref="System.ArgumentNullException"> /// Thrown if <paramref name="registrar"/> is <see langword="null"/>. /// </exception> /// <exception cref="System.InvalidOperationException"> /// Thrown if the value for <c>autoActivate</c> is not part of the /// recognized grammar. /// </exception> protected virtual void SetAutoActivate<TReflectionActivatorData, TSingleRegistrationStyle>(IConfiguration component, IRegistrationBuilder<object, TReflectionActivatorData, TSingleRegistrationStyle> registrar) where TReflectionActivatorData : ReflectionActivatorData where TSingleRegistrationStyle : SingleRegistrationStyle { if (registrar == null) { throw new ArgumentNullException(nameof(registrar)); } if (component["autoActivate"].ToFlexibleBoolean()) { registrar.AutoActivate(); } }
/// <summary> /// Sets the ownership model for the component. /// </summary> /// <param name="component"> /// The configuration data containing the component. The <c>ownership</c> /// content will be read from this configuration object and used /// to determine component ownership. /// </param> /// <param name="registrar"> /// The component registration on which component ownership is being set. /// </param> /// <remarks> /// <para> /// By default, this implementation understands <see langword="null"/> or empty /// values to be "default ownership model"; <c>lifetime-scope</c> or <c>LifetimeScope</c> /// is "owned by lifetime scope"; and <c>external</c> or <c>ExternallyOwned</c> is /// "externally owned." /// </para> /// <para> /// By default, this implementation understands the following grammar: /// </para> /// <list type="table"> /// <listheader> /// <term>Values</term> /// <description>Lifetime Scope</description> /// </listheader> /// <item> /// <term><see langword="null"/>, empty</term> /// <description>Default - no specified ownership model</description> /// </item> /// <item> /// <term><c>lifetime-scope</c>, <c>LifetimeScope</c></term> /// <description>Owned by lifetime scope</description> /// </item> /// <item> /// <term><c>external</c>, <c>ExternallyOwned</c></term> /// <description>Externally owned</description> /// </item> /// </list> /// <para> /// You may override this method to extend the available grammar for component ownership. /// </para> /// </remarks> /// <exception cref="System.ArgumentNullException"> /// Thrown if <paramref name="registrar"/> is <see langword="null"/>. /// </exception> /// <exception cref="System.InvalidOperationException"> /// Thrown if the value for <c>ownership</c> is not part of the /// recognized grammar. /// </exception> protected virtual void SetComponentOwnership<TReflectionActivatorData, TSingleRegistrationStyle>(IConfiguration component, IRegistrationBuilder<object, TReflectionActivatorData, TSingleRegistrationStyle> registrar) where TReflectionActivatorData : ReflectionActivatorData where TSingleRegistrationStyle : SingleRegistrationStyle { if (registrar == null) { throw new ArgumentNullException(nameof(registrar)); } string ownership = component["ownership"]; if (string.IsNullOrWhiteSpace(ownership)) { return; } ownership = ownership.Trim().Replace("-", ""); if (ownership.Equals("lifetimescope", StringComparison.OrdinalIgnoreCase)) { registrar.OwnedByLifetimeScope(); return; } if (ownership.Equals("external", StringComparison.OrdinalIgnoreCase) || ownership.Equals("externallyowned", StringComparison.OrdinalIgnoreCase)) { registrar.ExternallyOwned(); return; } throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, ConfigurationResources.UnrecognisedOwnership, ownership)); }
/// <summary> /// Reads configuration data for a component's configured property values /// and updates the component registration as needed. /// </summary> /// <param name="component"> /// The configuration data containing the component. The <c>properties</c> /// content will be read from this configuration object and used /// as the properties to inject. /// </param> /// <param name="registrar"> /// The component registration to update with property injection. /// </param> /// <exception cref="System.ArgumentNullException"> /// Thrown if <paramref name="component" /> or <paramref name="registrar" /> is <see langword="null" />. /// </exception> protected virtual void RegisterComponentProperties<TReflectionActivatorData, TSingleRegistrationStyle>(IConfiguration component, IRegistrationBuilder<object, TReflectionActivatorData, TSingleRegistrationStyle> registrar) where TReflectionActivatorData : ReflectionActivatorData where TSingleRegistrationStyle : SingleRegistrationStyle { if (component == null) { throw new ArgumentNullException(nameof(component)); } if (registrar == null) { throw new ArgumentNullException(nameof(registrar)); } foreach (var prop in component.GetProperties("properties")) { registrar.WithProperty(prop); } }
/// <summary> /// Reads configuration data for a component's exposed services /// and updates the component registration as needed. /// </summary> /// <param name="component"> /// The configuration data containing the component. The <c>services</c> /// content will be read from this configuration object and used /// as the services. /// </param> /// <param name="registrar"> /// The component registration to update with services. /// </param> /// <param name="defaultAssembly"> /// The default assembly, if any, from which unqualified type names /// should be resolved into types. /// </param> /// <exception cref="System.ArgumentNullException"> /// Thrown if <paramref name="component" /> or <paramref name="registrar" /> is <see langword="null" />. /// </exception> protected virtual void RegisterComponentServices<TReflectionActivatorData, TSingleRegistrationStyle>(IConfiguration component, IRegistrationBuilder<object, TReflectionActivatorData, TSingleRegistrationStyle> registrar, Assembly defaultAssembly) where TReflectionActivatorData : ReflectionActivatorData where TSingleRegistrationStyle : SingleRegistrationStyle { if (component == null) { throw new ArgumentNullException(nameof(component)); } if (registrar == null) { throw new ArgumentNullException(nameof(registrar)); } foreach (var service in this.EnumerateComponentServices(component, defaultAssembly)) { registrar.As(service); } }
/// <summary> /// Reads configuration data for a component's metadata /// and updates the component registration as needed. /// </summary> /// <param name="component"> /// The configuration data containing the component. The <c>metadata</c> /// content will be read from this configuration object and used /// as the metadata values. /// </param> /// <param name="registrar"> /// The component registration to update with metadata. /// </param> /// <param name="defaultAssembly"> /// The default assembly, if any, from which unqualified type names /// should be resolved into types. /// </param> /// <exception cref="System.ArgumentNullException"> /// Thrown if <paramref name="component" /> or <paramref name="registrar" /> is <see langword="null" />. /// </exception> protected virtual void RegisterComponentMetadata<TReflectionActivatorData, TSingleRegistrationStyle>(IConfiguration component, IRegistrationBuilder<object, TReflectionActivatorData, TSingleRegistrationStyle> registrar, Assembly defaultAssembly) where TReflectionActivatorData : ReflectionActivatorData where TSingleRegistrationStyle : SingleRegistrationStyle { if (component == null) { throw new ArgumentNullException(nameof(component)); } if (registrar == null) { throw new ArgumentNullException(nameof(registrar)); } foreach (var ep in component.GetSection("metadata").GetChildren()) { registrar.WithMetadata(ep["key"], TypeManipulation.ChangeToCompatibleType(ep["value"], ep.GetType("type", defaultAssembly))); } }
/// <summary> /// Sets the property injection on a registration based on options. /// </summary> /// <typeparam name="TLimit">The most specific type to which instances of the registration /// can be cast.</typeparam> /// <typeparam name="TActivatorData">Activator builder type.</typeparam> /// <typeparam name="TRegistrationStyle">Registration style type.</typeparam> /// <param name="registration">The registration to update.</param> /// <exception cref="System.ArgumentNullException"> /// Thrown if <paramref name="registration" /> is <see langword="null" />. /// </exception> protected virtual void SetPropertyInjection <TLimit, TActivatorData, TRegistrationStyle>(IRegistrationBuilder <TLimit, TActivatorData, TRegistrationStyle> registration) { this.provider.SetPropertyInjection(registration); }
public static void ApplyDefaultPerRequestConfiguration(this IRegistrationBuilder <object, object, object> registrationBuilder, AppStart config, bool dontAllowCircularDependencies = false) { registrationBuilder.ApplyDefaultConfiguration(config.LifetimeScopeConfigurator, dontAllowCircularDependencies); }
protected override void Load(ContainerBuilder builder) { Contract.Assert(builder != null, "Builder container is null"); builder.RegisterType <FoundationConfigurationSection>().As <IFoundationConfigurationSection>() .ExternallyOwned(); var configSection = ConfigurationManager.GetSection("rebel.foundation") as IFoundationConfigurationSection; builder.RegisterInstance(configSection) .As <IFoundationConfigurationSection>() .ExternallyOwned() .SingleInstance(); foreach (PersistenceProviderElement element in configSection.PersistenceProviders) { IList <Service> services = new List <Service>(); // Resolve the type itself Type implementationType = ConfigurationExtensions.GetTypeFromTypeConfigName(element.Type); // Offer to invoke the provider's setup module (if any exist) builder.RegisterModule(new ProviderAutoSetupModule(implementationType.Assembly, element.Key)); IRegistrationBuilder <object, ConcreteReflectionActivatorData, SingleRegistrationStyle> providerRegistrar = builder .RegisterType(implementationType) .Named <IPersistenceManager>(element.Key) .SingleInstance(); // Resolve the reader type from config Type readerType = ConfigurationExtensions.GetTypeFromTypeConfigName(element.Reader.Type); string compoundReaderKey = string.Format("{0}/{1}", element.Key, element.Reader.Key); // Overwrite the configuration key so that it is a compound of the reader and its parent provider element.Reader.InternalKey = compoundReaderKey; // Register the reader with IoC against the interface builder.RegisterType(readerType) // Name this registration .Named <IPersistenceReadWriter>(compoundReaderKey) // Allow passing in a named constructor parameter for the alias .WithParameter(new NamedParameter("alias", element.Reader.InternalKey)) // Allow passing in a resolved ITypeMapper .WithParameter(GenerateResolvedParameter <ITypeMapper>()) // Allow passing in a resolved IUnitOfWork .WithParameter(GenerateResolvedParameter <IUnitOfWork>()); // Register the reader with IoC against the concrete type declared in config too // TODO: There's a way to do this in one call with Autofac ;) builder.RegisterType(readerType) .Named(compoundReaderKey, readerType) .WithParameter(new NamedParameter("alias", element.Reader.InternalKey)) .WithParameter(GenerateResolvedParameter <ITypeMapper>()) .WithParameter(GenerateResolvedParameter <IUnitOfWork>()); providerRegistrar.WithParameter(element.Reader.ToParameter()); foreach (PersistenceReadWriterElement readWriter in element.ReadWriters) { Type repoType = ConfigurationExtensions.GetTypeFromTypeConfigName(readWriter.Type); string compoundRepositoryKey = string.Format("{0}/{1}", element.Key, readWriter.Key); // Overwrite the configuration key so that it is a compound of the read-writer and its parent provider readWriter.InternalKey = compoundRepositoryKey; builder .RegisterType(repoType) .Named <IPersistenceReadWriter>(compoundRepositoryKey) .WithParameter(new NamedParameter("alias", readWriter.InternalKey)) .WithParameter(GenerateResolvedParameter <ITypeMapper>()) .WithParameter(GenerateResolvedParameter <IUnitOfWork>()); builder .RegisterType(repoType) .Named(compoundRepositoryKey, repoType) .WithParameter(new NamedParameter("alias", readWriter.InternalKey)) .WithParameter(GenerateResolvedParameter <ITypeMapper>()) .WithParameter(GenerateResolvedParameter <IUnitOfWork>()); } //TODO: This only works at the moment because the two test providers accept one ReadWriter and we're only declaring //one in config. Need to refactor providers to accept a list of read-writers to complete the chaining refactor foreach (Parameter param in element.ReadWriters.ToParameters()) { providerRegistrar.WithParameter(param); } providerRegistrar.WithParameter(new TypedParameter(typeof(string), element.Key)); } }
/// <summary> /// Sets the property injection mode for the component. /// </summary> /// <param name="component"> /// The configuration data containing the component. The <c>injectProperties</c> /// content will be read from this configuration object and used /// to determine property injection status. /// </param> /// <param name="registrar"> /// The component registration on which the property injection mode is being set. /// </param> /// <remarks> /// <para> /// By default, this implementation understands <see langword="null"/>, empty, /// or <see langword="false"/> values (<c>false</c>, <c>0</c>, <c>no</c>) /// to mean "no property injection" and <see langword="true"/> /// values (<c>true</c>, <c>1</c>, <c>yes</c>) to mean "property injection /// should occur." /// </para> /// <para> /// You may override this method to extend the available grammar for property injection settings. /// </para> /// </remarks> /// <exception cref="System.ArgumentNullException"> /// Thrown if <paramref name="registrar"/> is <see langword="null"/>. /// </exception> /// <exception cref="System.InvalidOperationException"> /// Thrown if the value for <c>injectProperties</c> is not part of the /// recognized grammar. /// </exception> protected virtual void SetInjectProperties<TReflectionActivatorData, TSingleRegistrationStyle>(IConfiguration component, IRegistrationBuilder<object, TReflectionActivatorData, TSingleRegistrationStyle> registrar) where TReflectionActivatorData : ReflectionActivatorData where TSingleRegistrationStyle : SingleRegistrationStyle { if (registrar == null) { throw new ArgumentNullException(nameof(registrar)); } if (component["injectProperties"].ToFlexibleBoolean()) { registrar.PropertiesAutowired(PropertyWiringOptions.AllowCircularDependencies); } }
public static IRegistrationBuilder <TLimit, TReflectionActivatorData, TStyle> WithNullCache <TLimit, TReflectionActivatorData, TStyle>(this IRegistrationBuilder <TLimit, TReflectionActivatorData, TStyle> registration) where TReflectionActivatorData : ReflectionActivatorData { return(registration.WithParameter(Autofac.Core.ResolvedParameter.ForNamed <ICacheManager>("null"))); }
protected virtual void SetLifetimeScope<TReflectionActivatorData, TSingleRegistrationStyle>(IConfiguration component, IRegistrationBuilder<object, TReflectionActivatorData, TSingleRegistrationStyle> registrar) where TReflectionActivatorData : ReflectionActivatorData where TSingleRegistrationStyle : SingleRegistrationStyle { if (registrar == null) { throw new ArgumentNullException(nameof(registrar)); } string lifetimeScope = component["instanceScope"]; if (string.IsNullOrWhiteSpace(lifetimeScope)) { return; } lifetimeScope = lifetimeScope.Trim().Replace("-", ""); if (lifetimeScope.Equals("singleinstance", StringComparison.OrdinalIgnoreCase)) { registrar.SingleInstance(); return; } if (lifetimeScope.Equals("instanceperlifetimescope", StringComparison.OrdinalIgnoreCase) || lifetimeScope.Equals("perlifetimescope", StringComparison.OrdinalIgnoreCase)) { registrar.InstancePerLifetimeScope(); return; } if (lifetimeScope.Equals("instanceperdependency", StringComparison.OrdinalIgnoreCase) || lifetimeScope.Equals("perdependency", StringComparison.OrdinalIgnoreCase)) { registrar.InstancePerDependency(); return; } if (lifetimeScope.Equals("instanceperrequest", StringComparison.OrdinalIgnoreCase) || lifetimeScope.Equals("perrequest", StringComparison.OrdinalIgnoreCase)) { registrar.InstancePerRequest(); return; } throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, ConfigurationResources.UnrecognisedScope, lifetimeScope)); }
public static IRegistrationBuilder <TLimit, TConcreteActivatorData, SingleRegistrationStyle> AsQueryHandler <TLimit, TConcreteActivatorData>(this IRegistrationBuilder <TLimit, TConcreteActivatorData, SingleRegistrationStyle> registration) where TConcreteActivatorData : IConcreteActivatorData { Type queryHandlerType = registration.ActivatorData.Activator.LimitType; Type queryHandlerRegistrationType = queryHandlerType.GetInterfaces().FirstOrDefault(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IQueryHandlerAsync <,>)); if (queryHandlerRegistrationType == null) { throw new ArgumentException($"{queryHandlerType} doesn't implement {typeof(IQueryHandlerAsync<,>).Name} interface"); } TypedService queryHandlerService = new TypedService(queryHandlerRegistrationType); return(registration.As(queryHandlerService)); }
public static IRegistrationBuilder <TLimit, TActivatorData, TStyle> EnableParametersValidation <TLimit, TActivatorData, TStyle>( this IRegistrationBuilder <TLimit, TActivatorData, TStyle> builder) => builder.InterceptedBy(typeof(ValidationInterceptor));
/// <summary> /// /// </summary> /// <typeparam name="TLimit"></typeparam> /// <typeparam name="TConcreteReflectionActivatorData"></typeparam> /// <typeparam name="TRegistrationStyle"></typeparam> /// <param name="registration"></param> /// <param name="additionalInterfaces"></param> /// <returns></returns> public static IRegistrationBuilder <TLimit, TConcreteReflectionActivatorData, TRegistrationStyle> EnableClassInterceptors <TLimit, TConcreteReflectionActivatorData, TRegistrationStyle>( this IRegistrationBuilder <TLimit, TConcreteReflectionActivatorData, TRegistrationStyle> registration, params Type[] additionalInterfaces) where TConcreteReflectionActivatorData : ReflectionActivatorData { return(EnableClassInterceptors(registration, ProxyGenerationOptions.Default, additionalInterfaces)); }
public static IRegistrationBuilder <object, ScanningActivatorData, DynamicRegistrationStyle> RegisterServiceBus ( this ContainerBuilder builder) { var referenceAssemblies = builder.GetReferenceAssembly(); IRegistrationBuilder <object, ScanningActivatorData, DynamicRegistrationStyle> result = null; var assemblies = referenceAssemblies.Where( p => p.GetCustomAttribute <AssemblyModuleTypeAttribute>().Type == ModuleType.BusinessModule || p.GetCustomAttribute <AssemblyModuleTypeAttribute>().Type == ModuleType.Domain).ToList(); foreach (var assembly in assemblies) { result = builder.RegisterAssemblyTypes(assembly) .Where(t => typeof(IIntegrationEventHandler).GetTypeInfo().IsAssignableFrom(t)).AsImplementedInterfaces().SingleInstance(); result = builder.RegisterAssemblyTypes(assembly) .Where(t => typeof(IIntegrationEventHandler).IsAssignableFrom(t)).SingleInstance(); } return(result); }
protected virtual void SetInjectProperties <TReflectionActivatorData, TSingleRegistrationStyle>(IRegistrationBuilder <object, TReflectionActivatorData, TSingleRegistrationStyle> registrar, string injectProperties) where TReflectionActivatorData : ReflectionActivatorData where TSingleRegistrationStyle : SingleRegistrationStyle { if (registrar == null) { throw new ArgumentNullException("registrar"); } if (string.IsNullOrWhiteSpace(injectProperties)) { return; } string key; switch (key = injectProperties.Trim().ToUpperInvariant()) { case "NO": case "N": case "FALSE": case "0": return; case "YES": case "Y": case "TRUE": case "1": registrar.PropertiesAutowired(PropertyWiringOptions.AllowCircularDependencies); return; } throw new ConfigurationErrorsException(string.Format(CultureInfo.CurrentCulture, ConfigurationSettingsReaderResources.UnrecognisedInjectProperties, new object[] { injectProperties })); }
private static IRegistrationBuilder<object, IConcreteActivatorData, SingleRegistrationStyle> ApplyName(IRegistrationBuilder<object, IConcreteActivatorData, SingleRegistrationStyle> registration, string name, Type service) { if (string.IsNullOrEmpty(name)) return registration; return registration.Named(name, service); }
protected virtual void SetComponentOwnership <TReflectionActivatorData, TSingleRegistrationStyle>(IRegistrationBuilder <object, TReflectionActivatorData, TSingleRegistrationStyle> registrar, string ownership) where TReflectionActivatorData : ReflectionActivatorData where TSingleRegistrationStyle : SingleRegistrationStyle { if (registrar == null) { throw new ArgumentNullException("registrar"); } if (string.IsNullOrWhiteSpace(ownership)) { return; } string a; if ((a = ownership.Trim().ToUpperInvariant()) != null) { if (a == "LIFETIME-SCOPE" || a == "LIFETIMESCOPE") { registrar.OwnedByLifetimeScope(); return; } if (a == "EXTERNAL" || a == "EXTERNALLYOWNED") { registrar.ExternallyOwned(); return; } } throw new ConfigurationErrorsException(string.Format(CultureInfo.CurrentCulture, ConfigurationSettingsReaderResources.UnrecognisedOwnership, new object[] { ownership })); }
InstancePerProfilerSession <TLimit, TActivatorData, TRegistrationStyle>(this IRegistrationBuilder <TLimit, TActivatorData, TRegistrationStyle> builder) { return(builder.InstancePerMatchingLifetimeScope(Constants.ProfilerSessionScopeTag)); }
private static void SetLifetimeScope(DependencyLifecycle dependencyLifecycle, IRegistrationBuilder<object, ConcreteReflectionActivatorData, SingleRegistrationStyle> registrationBuilder) { switch (dependencyLifecycle) { case DependencyLifecycle.InstancePerCall: registrationBuilder.InstancePerDependency(); break; case DependencyLifecycle.SingleInstance: registrationBuilder.SingleInstance(); break; case DependencyLifecycle.InstancePerUnitOfWork: registrationBuilder.InstancePerLifetimeScope(); break; default: throw new ArgumentException("Unhandled lifecycle - " + dependencyLifecycle); } }
public static IRegistrationBuilder <object, ScanningActivatorData, DynamicRegistrationStyle> RegisterServices( this ContainerBuilder builder) { var referenceAssemblies = builder.GetReferenceAssembly(); IRegistrationBuilder <object, ScanningActivatorData, DynamicRegistrationStyle> result = null; if (builder == null) { throw new ArgumentNullException("builder"); } #region 接口服务注入 var interfaceAssemblies = referenceAssemblies.Where( p => p.GetCustomAttribute <AssemblyModuleTypeAttribute>().Type == ModuleType.InterFaceService || p.GetCustomAttribute <AssemblyModuleTypeAttribute>().Type == ModuleType.SystemModule).ToList(); foreach (var interfaceAssembly in interfaceAssemblies) { result = builder.RegisterAssemblyTypes(interfaceAssembly) .Where(t => t.Name.StartsWith("I")).Where(t => t.Name.EndsWith("Service")) .AsImplementedInterfaces(); } #endregion #region 领域服务注入 var domainAssemblies = referenceAssemblies.Where( p => p.GetCustomAttribute <AssemblyModuleTypeAttribute>().Type == ModuleType.BusinessModule || p.GetCustomAttribute <AssemblyModuleTypeAttribute>().Type == ModuleType.Domain).ToList(); foreach (var domainAssembly in domainAssemblies) { result = builder.RegisterAssemblyTypes(domainAssembly) .Where(t => t.Name.EndsWith("Service") && t.GetTypeInfo().GetCustomAttribute <ModuleNameAttribute>() == null).AsImplementedInterfaces(); // result = builder.RegisterAssemblyTypes(domainAssembly) //.Where(t => t.Name.EndsWith("Service") && t.GetTypeInfo().GetCustomAttribute<ModuleNameAttribute>() == null).EnableClassInterceptors(); var types = domainAssembly.GetTypes().Where(t => t.Name.EndsWith("Service") && t.GetTypeInfo().GetCustomAttribute <ModuleNameAttribute>() != null); foreach (var type in types) { var module = type.GetTypeInfo().GetCustomAttribute <ModuleNameAttribute>(); var interfaceObj = type.GetInterfaces() .FirstOrDefault(t => t.Name.StartsWith("I") && t.Name.EndsWith("Service")); if (interfaceObj != null) { builder.RegisterType(type).AsImplementedInterfaces().Named(module.ModuleName, interfaceObj); builder.RegisterType(type).Named(module.ModuleName, type); } } } #endregion return(result); }
Mutate <TLimit, TActivatorData, TRegistrationStyle>( IRegistrationBuilder <TLimit, TActivatorData, TRegistrationStyle> registration) => registration.EnableInterfaceInterceptors().InterceptedBy(typeof(FooInterceptor));
InstancePerHttpRequest <TLimit, TActivatorData, TStyle>( this IRegistrationBuilder <TLimit, TActivatorData, TStyle> registration, params object[] lifetimeScopeTags) { return(registration.InstancePerRequest(lifetimeScopeTags)); }
RegisterBusinessModules(this ContainerBuilder builder) { var referenceAssemblies = builder.GetReferenceAssembly(); IRegistrationBuilder <object, ScanningActivatorData, DynamicRegistrationStyle> result = null; if (builder == null) { throw new ArgumentNullException("builder"); } var repositoryAssemblies = referenceAssemblies.Where( p => p.GetCustomAttribute <AssemblyModuleTypeAttribute>().Type == ModuleType.BusinessModule || p.GetCustomAttribute <AssemblyModuleTypeAttribute>().Type == ModuleType.Domain).ToList(); foreach (var repositoryAssembly in repositoryAssemblies) { result = builder.RegisterAssemblyTypes(repositoryAssembly).AsImplementedInterfaces().SingleInstance(); } return(result); }
protected virtual void ExtendedHandlerRegisterationDetails(IRegistrationBuilder <object, SimpleActivatorData, SingleRegistrationStyle> registrationBuilder, Type handlerType) { }
public static IRegistrationBuilder <object, ScanningActivatorData, DynamicRegistrationStyle> RegisterWcfServices( this ContainerBuilder builder) { var referenceAssemblies = builder.GetReferenceAssembly(); IRegistrationBuilder <object, ScanningActivatorData, DynamicRegistrationStyle> result = null; if (builder == null) { throw new ArgumentNullException("builder"); } var interfaceAssemblies = referenceAssemblies.Where( p => p.GetCustomAttribute <AssemblyModuleTypeAttribute>().Type == ModuleType.WcfService).ToList(); foreach (var interfaceAssembly in interfaceAssemblies) { result = builder.RegisterAssemblyTypes(interfaceAssembly) .Where(t => t.Name.EndsWith("Service")).SingleInstance(); } return(result); }
public WebSiteRegistrator(IRegistrationBuilder builder) { _builder = builder; }