/// <summary> /// Return the sequence of methods to call while building the target object. /// </summary> /// <param name="context">Current build context.</param> /// <param name="resolverPolicyDestination">The <see cref='IPolicyList'/> to add any /// generated resolver objects into.</param> /// <returns>Sequence of methods to call.</returns> public IEnumerable <SelectedMethod> SelectMethods(IBuilderContext context, IPolicyList resolverPolicyDestination) { foreach (Tuple <MethodInfo, IEnumerable <InjectionParameterValue> > method in _methods) { Type typeToBuild = context.BuildKey.Type; SelectedMethod selectedMethod; var info = method.Item1.DeclaringType.GetTypeInfo(); var methodHasOpenGenericParameters = method.Item1.GetParameters() .Select(p => p.ParameterType.GetTypeInfo()) .Any(i => i.IsGenericType && i.ContainsGenericParameters); if (!methodHasOpenGenericParameters && !(info.IsGenericType && info.ContainsGenericParameters)) { selectedMethod = new SelectedMethod(method.Item1); } else { var closedMethodParameterTypes = method.Item1 .GetClosedParameterTypes(typeToBuild.GetTypeInfo().GenericTypeArguments); selectedMethod = new SelectedMethod(typeToBuild.GetMethodsHierarchical() .Single(m => m.Name.Equals(method.Item1.Name) && m.GetParameters().ParametersMatch(closedMethodParameterTypes))); } AddParameterResolvers(typeToBuild, resolverPolicyDestination, method.Item2, selectedMethod); yield return(selectedMethod); } }
/// <summary> /// Choose the constructor to call for the given type. /// </summary> /// <param name="context">Current build context</param> /// <param name="resolverPolicyDestination">The <see cref='IPolicyList'/> to add any /// generated resolver objects into.</param> /// <returns>The chosen constructor.</returns> public SelectedConstructor SelectConstructor(IBuilderContext context, IPolicyList resolverPolicyDestination) { SelectedConstructor result; var typeInfo = (context ?? throw new ArgumentNullException(nameof(context))).BuildKey .Type .GetTypeInfo(); var methodHasOpenGenericParameters = _ctor.GetParameters() .Select(p => p.ParameterType.GetTypeInfo()) .Any(i => i.IsGenericType && i.ContainsGenericParameters); var ctorTypeInfo = _ctor.DeclaringType.GetTypeInfo(); if (!methodHasOpenGenericParameters && !(ctorTypeInfo.IsGenericType && ctorTypeInfo.ContainsGenericParameters)) { result = new SelectedConstructor(_ctor); } else { var closedCtorParameterTypes = _ctor.GetClosedParameterTypes(typeInfo.GenericTypeArguments); var constructor = typeInfo.DeclaredConstructors .Single(c => !c.IsStatic && c.GetParameters().ParametersMatch(closedCtorParameterTypes)); result = new SelectedConstructor(constructor); } foreach (var parameterValue in _parameterValues) { var resolver = parameterValue.GetResolverPolicy(context.BuildKey.Type); result.AddParameterResolver(resolver); } return(result); }
/// <summary> /// Sets a generic individual policy. /// </summary> /// <typeparam name="TPolicyInterface">The interface the policy is registered under.</typeparam> /// <param name="policies"><see cref="IPolicyList"/> to add the policy to.</param> /// <param name="policy">The policy to be registered.</param> /// <param name="buildKey">The key the policy applies.</param> public static void Set <TPolicyInterface>(this IPolicyList policies, TPolicyInterface policy, object buildKey) where TPolicyInterface : IBuilderPolicy { var key = ParseBuildKey(buildKey); (policies ?? throw new ArgumentNullException(nameof(policies))).Set(key.Item1, key.Item2, typeof(TPolicyInterface), policy); }
void IContainerPolicyCreator.CreatePolicies( IPolicyList policyList, string instanceName, ConfigurationElement configurationObject, IConfigurationSource configurationSource) { CacheManagerData castConfigurationObject = (CacheManagerData)configurationObject; var cacheManagerName = instanceName; var cacheStorageName = castConfigurationObject.CacheStorage; var maximumElementsInCacheBeforeScavenging = castConfigurationObject.MaximumElementsInCacheBeforeScavenging; var numberToRemoveWhenScavenging = castConfigurationObject.NumberToRemoveWhenScavenging; var expirationPollFrequencyInSeconds = castConfigurationObject.ExpirationPollFrequencyInSeconds; policyList.Set <IBuildPlanPolicy>( new DelegateBuildPlanPolicy( context => { IBuilderContext backingStoreContext = context.CloneForNewBuild(NamedTypeBuildKey.Make <IBackingStore>(cacheStorageName), null); IBackingStore backingStore = (IBackingStore)context.Strategies.ExecuteBuildUp(backingStoreContext); CachingInstrumentationProvider instrumentationProvider = CreateInstrumentationProvider(cacheManagerName, configurationSource); return(new CacheManagerFactoryHelper().BuildCacheManager( cacheManagerName, backingStore, maximumElementsInCacheBeforeScavenging, numberToRemoveWhenScavenging, expirationPollFrequencyInSeconds, instrumentationProvider)); }), NamedTypeBuildKey.Make <CacheManager>(cacheManagerName)); }
/// <summary> /// Add policies to the <paramref name="policies"/> to configure the /// container to call this constructor with the appropriate parameter values. /// </summary> /// <param name="typeToCreate">Type to register.</param> /// <param name="name">Name used to resolve the type object.</param> /// <param name="policies">Policy list to add policies to.</param> public override void AddPolicies(Type typeToCreate, string name, IPolicyList policies) { ConstructorInfo ctor = FindConstructor(typeToCreate); policies.Set<IConstructorSelectorPolicy>( new SpecifiedConstructorSelectorPolicy(ctor, parameterValues.ToArray()), new NamedTypeBuildKey(typeToCreate, name)); }
public IEnumerable<SelectedProperty> SelectProperties(IBuilderContext context, IPolicyList resolverPolicyDestination) { var t = context.BuildKey.Type; var propertyNames = new HashSet<string>(); foreach (SelectedProperty prop in specifiedPropertiesPolicy.SelectProperties(context,resolverPolicyDestination)) { if (!propertyNames.Contains(prop.Property.Name)) { propertyNames.Add(prop.Property.Name); yield return prop; } } foreach (SelectedProperty prop in defaultProlicy.SelectProperties(context,resolverPolicyDestination)) { if (!propertyNames.Contains(prop.Property.Name)) { yield return prop; } } foreach (PropertyInfo prop in t.GetProperties(BindingFlags.Public | BindingFlags.SetProperty | BindingFlags.Instance)) { if (prop.GetIndexParameters().Length == 0 && prop.CanWrite && !ShoudBeIgnored(prop) && !propertyNames.Contains(prop.Name) && !prop.PropertyType.IsValueType && CanBeResolved(prop)) { yield return CreateSelectedProperty(context, prop); } } }
internal ContainerRegistration(Type registeredType, string name, IPolicyList policies) { this.buildKey = new NamedTypeBuildKey(registeredType, name); MappedToType = GetMappedType(policies); LifetimeManagerType = GetLifetimeManagerType(policies); LifetimeManager = GetLifetimeManager(policies); }
/// <summary> /// Choose the constructor to call for the given type. /// </summary> /// <param name="context">Current build context</param> /// <param name="resolverPolicyDestination">The <see cref='IPolicyList'/> to add any /// generated resolver objects into.</param> /// <returns>The chosen constructor.</returns> public SelectedConstructor SelectConstructor(IBuilderContext context, IPolicyList resolverPolicyDestination) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var typeToConstruct = context.BuildKey.Type; var constructors = typeToConstruct.GetConstructors(); var selectedConstructor = SelectConstructor(constructors.Where(ctor => ctor.IsDefined(typeof(InjectionAttribute), true)).ToArray()) ?? SelectConstructor(constructors.Where(ctor => ctor.IsDefined(typeof(InjectionConstructorAttribute), true)).ToArray()) ?? SelectConstructor(constructors); if (selectedConstructor != null) { var result = new SelectedConstructor(selectedConstructor); foreach (var parameter in selectedConstructor.GetParameters()) { var attrs = parameter.GetCustomAttributes <DependencyResolutionAttribute>(false).ToArray(); if (attrs.Length > 0) { // Since this attribute is defined with MultipleUse = false, the compiler will // enforce at most one. So we don't need to check for more. result.AddParameterResolver(attrs[0].CreateResolver(parameter.ParameterType)); } else { // No attribute, just go back to the container for the default for that type. result.AddParameterResolver(new NamedTypeDependencyResolverPolicy(parameter.ParameterType, null)); } } return(result); } return(null); }
/// <summary> /// Return the sequence of methods to call while building the target object. /// </summary> /// <param name = "context">Current build context.</param> /// <param name = "resolverPolicyDestination">The <see cref = 'IPolicyList' /> to add any /// generated resolver objects into.</param> /// <returns>Sequence of methods to call.</returns> public IEnumerable<SelectedMethod> SelectMethods(IBuilderContext context, IPolicyList resolverPolicyDestination) { foreach (Pair<MethodInfo, IEnumerable<InjectionParameterValue>> method in methods) { Type typeToBuild = context.BuildKey.Type; SelectedMethod selectedMethod; var typeReflector = new ReflectionHelper(method.First.DeclaringType); var methodReflector = new MethodReflectionHelper(method.First); if (!methodReflector.MethodHasOpenGenericParameters && !typeReflector.IsOpenGeneric) { selectedMethod = new SelectedMethod(method.First); } else { Type[] closedMethodParameterTypes = methodReflector.GetClosedParameterTypes(typeToBuild.GetGenericArguments()); selectedMethod = new SelectedMethod( typeToBuild.GetMethod(method.First.Name, closedMethodParameterTypes)); } SpecifiedMemberSelectorHelper.AddParameterResolvers( typeToBuild, resolverPolicyDestination, method.Second, selectedMethod); yield return selectedMethod; } }
private static IBuilderPolicy GetExtended(IPolicyList list, Type policyInterface, INamedType buildKey, Type buildType, out IPolicyList containingPolicyList) { containingPolicyList = null; if (null == buildType) { return(null); } // Check if generic if (buildType.GetTypeInfo().IsGenericType) { var newType = buildType.GetGenericTypeDefinition(); return(list.Get(newType, buildKey.Name, policyInterface, out containingPolicyList) ?? list.Get(newType, string.Empty, policyInterface, out containingPolicyList)); } // Check if array if (buildType.IsArray && buildType.GetArrayRank() == 1) { return(list.Get(typeof(Array), buildKey.Name, policyInterface, out containingPolicyList) ?? list.Get(typeof(Array), string.Empty, policyInterface, out containingPolicyList)); } // Check default for type return(list.Get(buildType, string.Empty, policyInterface, out containingPolicyList)); }
public SelectedConstructor SelectConstructor(IBuilderContext context, IPolicyList resolverPolicyDestination) { var originalConstructor = _originalConstructorSelectorPolicy.SelectConstructor(context, resolverPolicyDestination); if (originalConstructor.Constructor.GetParameters().All(arg => _container.CanResolve(arg.ParameterType))) { return(originalConstructor); } else { var newSelectedConstructor = FindNewCtor(originalConstructor); if (newSelectedConstructor == null) { return(originalConstructor); } foreach (var newParameterResolver in originalConstructor.GetParameterResolvers().Take(newSelectedConstructor.Constructor.GetParameters().Length)) { newSelectedConstructor.AddParameterResolver(newParameterResolver); } return(newSelectedConstructor); } }
void IContainerPolicyCreator.CreatePolicies( IPolicyList policyList, string instanceName, ConfigurationElement configurationObject, IConfigurationSource configurationSource) { T castConfigurationObject = (T)configurationObject; ConstructorInfo ctor = castConfigurationObject.Type.GetConstructor( BindingFlags.Public | BindingFlags.Instance, null, constructorTypes, null); if (ctor == null) { throw new ArgumentException( string.Format( CultureInfo.CurrentCulture, Resources.ExceptionCustomProviderTypeDoesNotHaveTheRequiredConstructor, castConfigurationObject.Type.AssemblyQualifiedName), "configurationObject"); } SelectedConstructor selectedCtor = new SelectedConstructor(ctor); string parameterKey = Guid.NewGuid().ToString(); selectedCtor.AddParameterKey(parameterKey); policyList.Set <IConstructorSelectorPolicy>( new FixedConstructorSelectorPolicy(selectedCtor), new NamedTypeBuildKey(castConfigurationObject.Type, instanceName)); policyList.Set <IDependencyResolverPolicy>( new ConstantResolverPolicy(new NameValueCollection(castConfigurationObject.Attributes)), parameterKey); }
public static TPolicyInterface Get <TPolicyInterface>(this IPolicyList policies, object buildKey, out IPolicyList containingPolicyList) where TPolicyInterface : IBuilderPolicy { Guard.ArgumentNotNull(policies, "policies"); return((TPolicyInterface)policies.Get(typeof(TPolicyInterface), buildKey, false, out containingPolicyList)); }
void IContainerPolicyCreator.CreatePolicies( IPolicyList policyList, string instanceName, ConfigurationElement configurationObject, IConfigurationSource configurationSource) { ConnectionStringSettings castConfigurationObject = (ConnectionStringSettings)configurationObject; IList <IOraclePackage> packages = new IOraclePackage[0]; OracleConnectionSettings oracleConnectionSettings = OracleConnectionSettings.GetSettings(configurationSource); if (oracleConnectionSettings != null) { OracleConnectionData oracleConnectionData = oracleConnectionSettings.OracleConnectionsData.Get(castConfigurationObject.Name); if (oracleConnectionData != null) { packages = new List <IOraclePackage>(from op in oracleConnectionData.Packages select(IOraclePackage) op); } } new PolicyBuilder <OracleDatabase, ConnectionStringSettings>( instanceName, castConfigurationObject, c => new OracleDatabase(c.ConnectionString, packages)) .AddPoliciesToPolicyList(policyList); }
/// <summary> /// Add policies to the <paramref name="policies"/> to configure the /// container to call this constructor with the appropriate parameter values. /// </summary> /// <param name="serviceType">Interface registered, ignored in this implementation.</param> /// <param name="implementationType">Type to register.</param> /// <param name="name">Name used to resolve the type object.</param> /// <param name="policies">Policy list to add policies to.</param> public override void AddPolicies(Type serviceType, Type implementationType, string name, IPolicyList policies) { ConstructorInfo ctor = this.FindConstructor(implementationType); policies.Set<IConstructorSelectorPolicy>( new SpecifiedConstructorSelectorPolicy(ctor, this.parameterValues.ToArray()), new NamedTypeBuildKey(implementationType, name)); }
public void InjectionConstructorSetsResolverForInterfaceToLookupInContainer() { InjectionConstructor ctor = new InjectionConstructor("Logger", typeof(ILogger)); TestingBuilderContext context = new TestingBuilderContext(); context.BuildKey = typeof(GuineaPig); IPolicyList policies = context.PersistentPolicies; ctor.AddPolicies(typeof(GuineaPig), policies); IConstructorSelectorPolicy selector = policies.Get <IConstructorSelectorPolicy>( new NamedTypeBuildKey(typeof(GuineaPig))); SelectedConstructor selected = selector.SelectConstructor(context); string[] keys = selected.GetParameterKeys(); Assert.AreEqual(typeof(GuineaPig).GetConstructor(Sequence.Collect(typeof(string), typeof(ILogger))), selected.Constructor); Assert.AreEqual(2, keys.Length); IDependencyResolverPolicy policy = context.Policies.Get <IDependencyResolverPolicy>(keys[1]); Assert.IsTrue(policy is NamedTypeDependencyResolverPolicy); }
void IContainerPolicyCreator.CreatePolicies( IPolicyList policyList, string instanceName, ConfigurationElement configurationObject, IConfigurationSource configurationSource) { IEnumerable <ConstructorInfo> ctors = from ctor in this.targetType.GetConstructors(BindingFlags.Public | BindingFlags.Instance) orderby ctor.GetParameters().Length descending select ctor; foreach (ConstructorInfo ctor in ctors) { if (TryToMatchAndAddPolicies(ctor, configurationObject, policyList, instanceName)) { return; } } throw new ArgumentException( string.Format( CultureInfo.CurrentCulture, Resources.ExceptionUnableToMatchConstructorToConfigurationObject, configurationObject.GetType().AssemblyQualifiedName, this.targetType.AssemblyQualifiedName)); }
private ILifetimePolicy GetLifetimePolicy(IBuilderContext context, out IPolicyList source) { var policy = context.Policies.Get(context.OriginalBuildKey.Type, context.OriginalBuildKey.Name, typeof(ILifetimePolicy), out source); if (policy == null && context.OriginalBuildKey.Type.GetTypeInfo().IsGenericType) { policy = context.Policies.Get(context.BuildKey.Type.GetGenericTypeDefinition(), context.BuildKey.Name, typeof(ILifetimePolicy), out source); if (!(policy is ILifetimeFactoryPolicy factoryPolicy)) { return(null); } lock (_genericLifetimeManagerLock) { // check whether the policy for closed-generic has been added since first checked var newLifetime = (ILifetimePolicy)source.Get(context.OriginalBuildKey.Type, context.OriginalBuildKey.Name, typeof(ILifetimePolicy), out _); if (null == newLifetime) { newLifetime = factoryPolicy.CreateLifetimePolicy(); source.Set(context.OriginalBuildKey.Type, context.OriginalBuildKey.Name, typeof(ILifetimePolicy), newLifetime); if (newLifetime is IDisposable) { context.Lifetime.Add(newLifetime); } } return(newLifetime); } } return((ILifetimePolicy)policy); }
/// <summary> /// Return the sequence of methods to call while building the target object. /// </summary> /// <param name="context">Current build context.</param> /// <param name="resolverPolicyDestination">The <see cref='IPolicyList'/> to add any /// generated resolver objects into.</param> /// <returns>Sequence of methods to call.</returns> public IEnumerable <SelectedMethod> SelectMethods(IBuilderContext context, IPolicyList resolverPolicyDestination) { foreach (Pair <MethodInfo, IEnumerable <InjectionParameterValue> > method in methods) { Type typeToBuild = context.BuildKey.Type; SelectedMethod selectedMethod; ReflectionHelper typeReflector = new ReflectionHelper(method.First.DeclaringType); MethodReflectionHelper methodReflector = new MethodReflectionHelper(method.First); if (!methodReflector.MethodHasOpenGenericParameters && !typeReflector.IsOpenGeneric) { selectedMethod = new SelectedMethod(method.First); } else { Type[] closedMethodParameterTypes = methodReflector.GetClosedParameterTypes(typeToBuild.GetTypeInfo().GenericTypeArguments); selectedMethod = new SelectedMethod( typeToBuild.GetMethodHierarchical(method.First.Name, closedMethodParameterTypes)); } SpecifiedMemberSelectorHelper.AddParameterResolvers( typeToBuild, resolverPolicyDestination, method.Second, selectedMethod); yield return(selectedMethod); } }
public void InjectionConstructorInsertsChooserForConstructorWithParameters() { string expectedString = "Hello"; int expectedInt = 12; var ctor = new InjectionConstructor(expectedString, expectedInt); var context = new MockBuilderContext { BuildKey = new NamedTypeBuildKey(typeof(GuineaPig)) }; IPolicyList policies = context.PersistentPolicies; ctor.AddPolicies(typeof(GuineaPig), policies); var selector = policies.Get <IConstructorSelectorPolicy>( new NamedTypeBuildKey(typeof(GuineaPig))); SelectedConstructor selected = selector.SelectConstructor(context, policies); string[] keys = selected.GetParameterKeys(); Assert.AreEqual(typeof(GuineaPig).GetConstructor(Sequence.Collect(typeof(string), typeof(int))), selected.Constructor); Assert.AreEqual(2, keys.Length); Assert.AreEqual(expectedString, (string)ResolveValue(policies, keys[0])); Assert.AreEqual(expectedInt, (int)ResolveValue(policies, keys[1])); }
public SelectedConstructor SelectConstructor(IBuilderContext context, IPolicyList resolverPolicyDestination) { SelectedConstructor originalConstructor = originalConstructorSelectorPolicy.SelectConstructor(context, resolverPolicyDestination); return(FindNewConstructor(originalConstructor, interceptingType)); }
/// <summary> /// Finish the creation process by adding all the collected policies to <paramref name="policyList"/>. /// </summary> /// <param name="policyList">The destination <see cref="IPolicyList"/>.</param> public void AddPoliciesToPolicyList(IPolicyList policyList) { CheckFinished(); if (this.propertyWaitCount > 0) { throw new InvalidOperationException(Resources.ExceptionPolicyBuilderStillWaitingForPropertyPolicy); } this.finished = true; if (this.selectedConstructor != null) { policyList.Set <IConstructorSelectorPolicy>( new FixedConstructorSelectorPolicy(this.selectedConstructor), this.instanceKey); } if (this.selectedProperties.Count > 0) { policyList.Set <IPropertySelectorPolicy>( new FixedPropertySelectorPolicy(this.selectedProperties), this.instanceKey); } foreach (var item in this.resolverPolicies) { policyList.Set(item.Value, item.Key); } }
private static void CreateCacheManagerLifetimePolicies(IPolicyList policyList, IUnityContainer container, IEnumerable <CacheManagerDataBase> cacheManagers) { foreach (var cacheManagerData in cacheManagers) { container.RegisterType(cacheManagerData.Type, cacheManagerData.Name, new ContainerControlledLifetimeManager()); } }
public object Resolve(Type type, string name, ImplicitRegistration registration) { unsafe { var thisContext = this; var context = new BuilderContext { Lifetime = Lifetime, Registration = registration, RegistrationType = type, Name = name, Type = registration is ExplicitRegistration containerRegistration ? containerRegistration.Type : type, ExecutePlan = ExecutePlan, ResolvePlan = ResolvePlan, List = List, Overrides = Overrides, DeclaringType = Type, #if !NET40 Parent = new IntPtr(Unsafe.AsPointer(ref thisContext)) #endif }; return(ExecutePlan(registration.BuildChain, ref context)); } }
public static void SetDefault <TPolicyInterface>(this IPolicyList policies, TPolicyInterface policy) where TPolicyInterface : IBuilderPolicy { ClubCloud.Core.Unity.Utility.Guard.ArgumentNotNull(policies, "policies"); policies.SetDefault(typeof(TPolicyInterface), policy); }
/// <summary> /// Get the non default policy. /// </summary> /// <param name="policies"><see cref="IPolicyList"/> to search.</param> /// <param name="policyInterface">The interface the policy is registered under.</param> /// <param name="buildKey">The key the policy applies.</param> /// <param name="localOnly">true if the policy searches local only; otherwise false to seach up the parent chain.</param> /// <returns>The policy in the list, if present; returns null otherwise.</returns> public static IBuilderPolicy GetNoDefault(this IPolicyList policies, Type policyInterface, object buildKey, bool localOnly) { IPolicyList containingPolicyList; return(policies.GetNoDefault(policyInterface, buildKey, localOnly, out containingPolicyList)); }
public void CreatePolicies( IPolicyList policyList, string instanceName, ConfigurationElement configurationObject, IConfigurationSource configurationSource) { throw new NotImplementedException(); }
/// <summary> /// Add policies to the <paramref name="policies"/> to configure the /// container to call this constructor with the appropriate parameter values. /// </summary> /// <param name="typeToCreate">Type to register.</param> /// <param name="name">Name used to resolve the type object.</param> /// <param name="policies">Policy list to add policies to.</param> public override void AddPolicies(Type typeToCreate, string name, IPolicyList policies) { ConstructorInfo ctor = FindConstructor(typeToCreate); policies.Set <IConstructorSelectorPolicy>( new SpecifiedConstructorSelectorPolicy(ctor, parameterValues.ToArray()), new NamedTypeBuildKey(typeToCreate, name)); }
/// <summary> /// Remove the currently tracked resolvers from the given policy list. /// </summary> /// <param name="policies">Policy list to remove the resolvers from.</param> public void RemoveResolvers(IPolicyList policies) { foreach (object key in keys) { policies.Clear <IDependencyResolverPolicy>(key); } keys.Clear(); }
/// <summary> /// Add policies to the <paramref name="policies"/> to configure the container with /// an appropriate <see cref="IInstanceInterceptionPolicy"/> /// </summary> /// <param name="serviceType">Type of the interface being registered. This parameter is /// ignored by this class.</param> /// <param name="implementationType">Type to register.</param> /// <param name="name">Name used to resolve the type object.</param> /// <param name="policies">Policy list to add policies to.</param> public override void AddPolicies(Type serviceType, Type implementationType, string name, IPolicyList policies) { var key = new NamedTypeBuildKey(implementationType); policies.Set<IInstanceInterceptionPolicy>(new FixedInstanceInterceptionPolicy(Interceptor), key); var piabInjectionMember = new InterceptionBehavior<PolicyInjectionBehavior>(); piabInjectionMember.AddPolicies(serviceType, implementationType, name, policies); }
/// <summary> /// Remove the currently tracked resolvers from the given policy list. /// </summary> /// <param name="policies">Policy list to remove the resolvers from.</param> public void RemoveResolvers(IPolicyList policies) { foreach(object key in keys) { policies.Clear<IDependencyResolverPolicy>(key); } keys.Clear(); }
public static TPolicyInterface GetPolicy <TPolicyInterface>(this IPolicyList list, INamedType buildKey, out IPolicyList containingPolicyList) { return((TPolicyInterface)(list.GetPolicyForKey(typeof(TPolicyInterface), buildKey, out containingPolicyList) ?? (buildKey.Type.GetTypeInfo().IsGenericType ? list.Get(buildKey.Type.GetGenericTypeDefinition(), buildKey.Name, typeof(TPolicyInterface), out containingPolicyList) ?? list.Get(null, null, typeof(TPolicyInterface), out containingPolicyList) : list.Get(null, null, typeof(TPolicyInterface), out containingPolicyList)))); }
public static void Set <TPolicyInterface>(this IPolicyList policies, TPolicyInterface policy, object buildKey) where TPolicyInterface : IBuilderPolicy { Guard.ArgumentNotNull(policies, "policies"); policies.Set(typeof(TPolicyInterface), policy, buildKey); }
/// <summary> /// Remove the resolvers for the given build key. /// </summary> /// <param name="policies">Policy list containing the build key.</param> /// <param name="buildKey">Build key.</param> public static void RemoveResolvers(IPolicyList policies, object buildKey) { IDependencyResolverTrackerPolicy tracker = policies.Get<IDependencyResolverTrackerPolicy>(buildKey); if (tracker != null) { tracker.RemoveResolvers(policies); } }
public SelectedConstructor SelectConstructor(IBuilderContext context, IPolicyList resolverPoliciesDestination) { var selectedConstructor = new SelectedConstructor(typeof(T).GetConstructor(new[] { typeof(object) })); selectedConstructor.AddParameterResolver(this.parameterResolverPolicy); return(selectedConstructor); }
/// <summary> /// Add policies to the <paramref name="policies"/> to configure the /// container to call this constructor with the appropriate parameter values. /// </summary> /// <param name="serviceType">Type of interface registered, ignored in this implementation.</param> /// <param name="implementationType">Type to register.</param> /// <param name="name">Name used to resolve the type object.</param> /// <param name="policies">Policy list to add policies to.</param> public override void AddPolicies(Type serviceType, Type implementationType, string name, IPolicyList policies) { MethodInfo methodInfo = this.FindMethod(implementationType); this.ValidateMethodCanBeInjected(methodInfo, implementationType); SpecifiedMethodsSelectorPolicy selector = GetSelectorPolicy(policies, implementationType, name); selector.AddMethodAndParameters(methodInfo, this.methodParameters); }
/// <summary> /// Add policies to the <paramref name="policies"/> to configure the /// container to call this constructor with the appropriate parameter values. /// </summary> /// <param name="serviceType">Type of interface being registered. If no interface, /// this will be null. This parameter is ignored in this implementation.</param> /// <param name="implementationType">Type of concrete type being registered.</param> /// <param name="name">Name used to resolve the type object.</param> /// <param name="policies">Policy list to add policies to.</param> public override void AddPolicies(Type serviceType, Type implementationType, string name, IPolicyList policies) { Guard.ArgumentNotNull(implementationType, "implementationType"); Guard.ArgumentNotNull(policies, "policies"); var policy = new FactoryDelegateBuildPlanPolicy(this.factoryFunc); policies.Set<IBuildPlanPolicy>(policy, new NamedTypeBuildKey(implementationType, name)); }
private static IBuilderPolicy GetPolicyForType(this IPolicyList list, Type policyInterface, Type buildType, out IPolicyList containingPolicyList) { if (buildType != null) { return(list.Get(policyInterface, buildType, out containingPolicyList)); } containingPolicyList = null; return(null); }
private static IBuilderPolicy GetPolicyForOpenGenericType(this IPolicyList list, Type policyInterface, Type buildType, out IPolicyList containingPolicyList) { if (buildType != null && buildType.GetTypeInfo().IsGenericType) { return(list.Get(policyInterface, buildType.GetGenericTypeDefinition(), out containingPolicyList)); } containingPolicyList = null; return(null); }
private Type GetMappedType(IPolicyList policies) { var mappingPolicy = policies.Get<IBuildKeyMappingPolicy>(buildKey); if (mappingPolicy != null) { return mappingPolicy.Map(buildKey, null).Type; } return buildKey.Type; }
/// <summary> /// Create a new <see cref="BuilderContext"/> using the explicitly provided /// values. /// </summary> /// <param name="chain">The <see cref="IStrategyChain"/> to use for this context.</param> /// <param name="lifetime">The <see cref="ILifetimeContainer"/> to use for this context.</param> /// <param name="persistentPolicies">The set of persistent policies to use for this context.</param> /// <param name="transientPolicies">The set of transient policies to use for this context. It is /// the caller's responsibility to ensure that the transient and persistent policies are properly /// combined.</param> /// <param name="buildKey">Build key for this context.</param> /// <param name="existing">Existing object to build up.</param> public BuilderContext(IStrategyChain chain, ILifetimeContainer lifetime, IPolicyList persistentPolicies, IPolicyList transientPolicies, NamedTypeBuildKey buildKey, object existing) { this.chain = chain; this.lifetime = lifetime; this.persistentPolicies = persistentPolicies; this.policies = transientPolicies; this.originalBuildKey = buildKey; this.BuildKey = buildKey; this.Existing = existing; }
private static SpecifiedMethodsSelectorPolicy GetSelectorPolicy(IPolicyList policies, Type typeToCreate, string name) { var key = new NamedTypeBuildKey(typeToCreate, name); var selector = policies.GetNoDefault<IMethodSelectorPolicy>(key, false); if (selector == null || !(selector is SpecifiedMethodsSelectorPolicy)) { selector = new SpecifiedMethodsSelectorPolicy(); policies.Set<IMethodSelectorPolicy>(selector, key); } return (SpecifiedMethodsSelectorPolicy)selector; }
public override void AddPolicies(Type serviceType, Type implementationType, string name, IPolicyList policies) { if (serviceType == null) throw new ArgumentNullException(nameof(serviceType), "The service type cannot be null"); if (implementationType == null) throw new ArgumentNullException(nameof(implementationType), "The implementation type cannot be null"); policies.Set( typeof(ILazyProxyPolicy), new LazyProxyPolicy(serviceType, implementationType), new NamedTypeBuildKey(serviceType, name)); }
/// <summary> /// Add policies to the <paramref name="policies"/> to configure the /// container to call this constructor with the appropriate parameter values. /// </summary> /// <param name="serviceType">Type of interface being registered. If no interface, /// this will be null.</param> /// <param name="implementationType">Type of concrete type being registered.</param> /// <param name="name">Name used to resolve the type object.</param> /// <param name="policies">Policy list to add policies to.</param> public override void AddPolicies(Type serviceType, Type implementationType, string name, IPolicyList policies) { if(IsInstanceInterceptor) { AddDefaultInstanceInterceptor(implementationType, policies); } else { AddDefaultTypeInterceptor(implementationType, policies); } }
/// <summary> /// Add policies to the <paramref name="policies"/> to configure the container to use the represented /// <see cref="IInterceptionBehavior"/> for the supplied parameters. /// </summary> /// <param name="serviceType">Interface being registered.</param> /// <param name="implementationType">Type to register.</param> /// <param name="name">Name used to resolve the type object.</param> /// <param name="policies">Policy list to add policies to.</param> public override void AddPolicies(Type serviceType, Type implementationType, string name, IPolicyList policies) { if (this.explicitBehavior != null) { this.AddExplicitBehaviorPolicies(implementationType, name, policies); } else { this.AddKeyedPolicies(implementationType, name, policies); } }
/// <summary> /// Add dependency resolvers to the policy set. /// </summary> /// <param name="policies">PolicyList to add the resolvers to.</param> /// <param name="parameterValues">Objects supplying the dependency resolvers.</param> /// <param name="result">Result object to store the keys in.</param> public static void AddParameterResolvers(IPolicyList policies, IEnumerable<InjectionParameterValue> parameterValues, SelectedMemberWithParameters result) { foreach(InjectionParameterValue parameterValue in parameterValues) { string key = Guid.NewGuid().ToString(); policies.Set<IDependencyResolverPolicy>(parameterValue.GetResolverPolicy(), key); result.AddParameterKey(key); } }
/// <summary> /// Get the list of behaviors for the current type so that it can be added to. /// </summary> /// <param name="policies">Policy list.</param> /// <param name="implementationType">Implementation type to set behaviors for.</param> /// <param name="name">Name type is registered under.</param> /// <returns>An instance of <see cref="InterceptionBehaviorsPolicy"/>.</returns> protected override InterceptionBehaviorsPolicy GetBehaviorsPolicy(IPolicyList policies, Type implementationType, string name) { var policy = policies.GetNoDefault<IInterceptionBehaviorsPolicy>(implementationType, false); if ((policy == null) || !(policy is InterceptionBehaviorsPolicy)) { policy = new InterceptionBehaviorsPolicy(); policies.Set(policy, implementationType); } return (InterceptionBehaviorsPolicy) policy; }
/// <summary> /// Create a new <see cref="BuilderContext"/> using the explicitly provided /// values. /// </summary> /// <param name="chain">The <see cref="IStrategyChain"/> to use for this context.</param> /// <param name="locator">The <see cref="IReadWriteLocator"/> to use for this context.</param> /// <param name="lifetime">The <see cref="ILifetimeContainer"/> to use for this context.</param> /// <param name="persistentPolicies">The set of persistent policies to use for this context.</param> /// <param name="transientPolicies">The set of transient policies to use for this context. It is /// the caller's responsibility to ensure that the transient and persistent policies are properly /// combined.</param> /// <param name="buildKey">Build key for this context.</param> /// <param name="existing">Existing object to build up.</param> public BuilderContext(IStrategyChain chain, IReadWriteLocator locator, ILifetimeContainer lifetime, IPolicyList persistentPolicies, IPolicyList transientPolicies, object buildKey, object existing) { this.chain = chain; this.lifetime = lifetime; this.locator = locator; this.persistentPolicies = persistentPolicies; this.policies = transientPolicies; this.originalBuildKey = buildKey; this.buildKey = buildKey; this.existing = existing; }
// Helper methods for adding and removing the tracker policy. /// <summary> /// Get an instance that implements <see cref="IDependencyResolverTrackerPolicy"/>, /// either the current one in the policy set or creating a new one if it doesn't /// exist. /// </summary> /// <param name="policies">Policy list to look up from.</param> /// <param name="buildKey">Build key to track.</param> /// <returns>The resolver tracker.</returns> public static IDependencyResolverTrackerPolicy GetTracker(IPolicyList policies, object buildKey) { IDependencyResolverTrackerPolicy tracker = policies.Get<IDependencyResolverTrackerPolicy>(buildKey); if (tracker == null) { tracker = new DependencyResolverTrackerPolicy(); policies.Set<IDependencyResolverTrackerPolicy>(tracker, buildKey); } return tracker; }
/// <summary> /// Create a new <see cref="BuilderContext"/> using the explicitly provided /// values. /// </summary> /// <param name="chain">The <see cref="IStrategyChain"/> to use for this context.</param> /// <param name="lifetime">The <see cref="ILifetimeContainer"/> to use for this context.</param> /// <param name="persistentPolicies">The set of persistent policies to use for this context.</param> /// <param name="transientPolicies">The set of transient policies to use for this context. It is /// the caller's responsibility to ensure that the transient and persistent policies are properly /// combined.</param> /// <param name="buildKey">Build key for this context.</param> /// <param name="existing">Existing object to build up.</param> public BuilderContext(IStrategyChain chain, ILifetimeContainer lifetime, IPolicyList persistentPolicies, IPolicyList transientPolicies, NamedTypeBuildKey buildKey, object existing) { this.chain = chain; this.lifetime = lifetime; this.persistentPolicies = persistentPolicies; this.policies = transientPolicies; this.originalBuildKey = buildKey; this.BuildKey = buildKey; this.Existing = existing; this.resolverOverrides = new CompositeResolverOverride(); this.ownsOverrides = true; }
public override void AddPolicies(Type serviceType, Type implementationType, string name, IPolicyList policies) { var key = new NamedTypeBuildKey(implementationType, name); var policy = policies.Get<InterceptorPolicy>(key); if (policy == null) { policy = new InterceptorPolicy(); policies.Set(policy, key); } policy.AddInterceptor(this.interceptorContainer); }
private void AddExplicitBehaviorPolicies(Type implementationType, string name, IPolicyList policies) { var lifetimeManager = new ContainerControlledLifetimeManager(); lifetimeManager.SetValue(explicitBehavior); var behaviorName = Guid.NewGuid().ToString(); var newBehaviorKey = new NamedTypeBuildKey(explicitBehavior.GetType(), behaviorName); policies.Set<ILifetimePolicy>(lifetimeManager, newBehaviorKey); InterceptionBehaviorsPolicy behaviorsPolicy = GetBehaviorsPolicy(policies, implementationType, name); behaviorsPolicy.AddBehaviorKey(newBehaviorKey); }
/// <summary> /// Initialize a new instance of the <see cref = "BuilderContext" /> class with a <see cref = "IStrategyChain" />, /// <see cref = "ILifetimeContainer" />, <see cref = "IPolicyList" /> and the /// build key used to start this build operation. /// </summary> /// <param name = "chain">The <see cref = "IStrategyChain" /> to use for this context.</param> /// <param name = "lifetime">The <see cref = "ILifetimeContainer" /> to use for this context.</param> /// <param name = "policies">The <see cref = "IPolicyList" /> to use for this context.</param> /// <param name = "originalBuildKey">Build key to start building.</param> /// <param name = "existing">The existing object to build up.</param> public BuilderContext(IStrategyChain chain, ILifetimeContainer lifetime, IPolicyList policies, NamedTypeBuildKey originalBuildKey, object existing) { this.chain = chain; this.lifetime = lifetime; this.originalBuildKey = originalBuildKey; BuildKey = originalBuildKey; persistentPolicies = policies; this.policies = new PolicyList(persistentPolicies); Existing = existing; }
public override void AddPolicies(Type typeToCreate, string name, IPolicyList policies) { Guard.ArgumentNotNull(typeToCreate, "typeToCreate"); PropertyInfo propInfo = typeToCreate.GetProperty(propertyName); GuardPropertyExists(propInfo, typeToCreate, propertyName); GuardPropertyIsSettable(propInfo); GuardPropertyIsNotIndexer(propInfo); InitializeParameterValue(propInfo); GuardPropertyValueIsCompatible(propInfo, parameterValue); SpecifiedPropertiesSelectorPolicy selector = GetSelectorPolicy(policies, typeToCreate, name); selector.AddPropertyAndValue(propInfo, parameterValue); }
/// <summary> /// Add dependency resolvers to the parameter set. /// </summary> /// <param name="typeToBuild">Type that's currently being built (used to resolve open generics).</param> /// <param name="policies">PolicyList to add the resolvers to.</param> /// <param name="parameterValues">Objects supplying the dependency resolvers.</param> /// <param name="result">Result object to store the keys in.</param> public static void AddParameterResolvers(Type typeToBuild, IPolicyList policies, IEnumerable<InjectionParameterValue> parameterValues, SelectedMemberWithParameters result) { Microsoft.Practices.Unity.Utility.Guard.ArgumentNotNull(policies, "policies"); Microsoft.Practices.Unity.Utility.Guard.ArgumentNotNull(parameterValues, "parameterValues"); Microsoft.Practices.Unity.Utility.Guard.ArgumentNotNull(result, "result"); foreach (InjectionParameterValue parameterValue in parameterValues) { var resolver = parameterValue.GetResolverPolicy(typeToBuild); result.AddParameterResolver(resolver); } }
internal static InterceptionBehaviorsPolicy GetOrCreate( IPolicyList policies, Type typeToCreate, string name) { NamedTypeBuildKey key = new NamedTypeBuildKey(typeToCreate, name); IInterceptionBehaviorsPolicy policy = policies.GetNoDefault<IInterceptionBehaviorsPolicy>(key, false); if ((policy == null) || !(policy is InterceptionBehaviorsPolicy)) { policy = new InterceptionBehaviorsPolicy(); policies.Set<IInterceptionBehaviorsPolicy>(policy, key); } return (InterceptionBehaviorsPolicy)policy; }
/// <summary> /// Add policies to the <paramref name="policies"/> to configure the /// container to call this constructor with the appropriate parameter values. /// </summary> /// <param name="typeToCreate">Type to register.</param> /// <param name="name">Name used to resolve the type object.</param> /// <param name="policies">Policy list to add policies to.</param> public override void AddPolicies(Type typeToCreate, string name, IPolicyList policies) { MethodInfo methodInfo = typeToCreate.GetMethod(methodName, Sequence.ToArray( Sequence.Map<InjectionParameterValue, Type>(methodParameters, delegate(InjectionParameterValue value) { return value.ParameterType; }))); ValidateMethodCanBeInjected(methodInfo, typeToCreate); SpecifiedMethodsSelectorPolicy selector = GetSelectorPolicy(policies, typeToCreate, name); selector.AddMethodAndParameters(methodInfo, methodParameters); }
internal static AdditionalInterfacesPolicy GetOrCreate( IPolicyList policies, Type typeToCreate, string name) { NamedTypeBuildKey key = new NamedTypeBuildKey(typeToCreate, name); IAdditionalInterfacesPolicy policy = policies.GetNoDefault<IAdditionalInterfacesPolicy>(key, false); if ((policy == null) || !(policy is AdditionalInterfacesPolicy)) { policy = new AdditionalInterfacesPolicy(); policies.Set<IAdditionalInterfacesPolicy>(policy, key); } return (AdditionalInterfacesPolicy)policy; }
/// <summary> /// Add policies to the <paramref name="policies"/> to configure the /// container to call this constructor with the appropriate parameter values. /// </summary> /// <param name="serviceType">Type of interface being registered. If no interface, /// this will be null.</param><param name="implementationType">Type of concrete type being registered.</param><param name="name">Name used to resolve the type object.</param><param name="policies">Policy list to add policies to.</param> public override void AddPolicies(Type serviceType, Type implementationType, string name, IPolicyList policies) { if (implementationType == null) throw new ArgumentNullException("implementationType"); if(!implementationType.IsGenericType || implementationType.GetGenericTypeDefinition() != typeof(Validator<>)) { throw new InvalidOperationException(Resources.IllegalUseOfInjectionValidationSource); } var key = new NamedTypeBuildKey(implementationType, name); var policy = new ValidationSpecificationSourcePolicy(Source); policies.Set<ValidationSpecificationSourcePolicy>(policy, key); }