/// <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 = FindExactMatchingConstructor(implementationType); if (ctor == null) { //if exact matching ctor not found, use the longest one and try to adjust the parameters. //use given Params if type matches otherwise use the type to advise Unity to resolve later ctor = FindLongestConstructor(implementationType); if (ctor != null) { //adjust parameters var newParams = new List <InjectionParameterValue>(); foreach (var parameter in ctor.GetParameters()) { var injectionParameterValue = _parameterValues.FirstOrDefault(value => value.MatchesType(parameter.ParameterType)); if (injectionParameterValue != null) { newParams.Add(injectionParameterValue); _parameterValues.Remove(injectionParameterValue); } else { newParams.Add(InjectionParameterValue.ToParameter(parameter.ParameterType)); } } _parameterValues = newParams; } else { throw new InvalidOperationException( string.Format( CultureInfo.CurrentCulture, "No constructor found for type {0}.", implementationType.GetTypeInfo().Name)); } } policies.Set <IConstructorSelectorPolicy>( new SpecifiedConstructorSelectorPolicy(ctor, _parameterValues.ToArray()), new NamedTypeBuildKey(implementationType, name)); }
/// <summary> /// Create an instance of <see cref="DependencyOverride"/> to override /// the given type with the given value. /// </summary> /// <param name="typeToConstruct">Type of the dependency.</param> /// <param name="dependencyValue">Value to use.</param> public DependencyOverride(Type typeToConstruct, object dependencyValue) { this.typeToConstruct = typeToConstruct; this.dependencyValue = InjectionParameterValue.ToParameter(dependencyValue); }
/// <summary> /// Configure the container to inject the given property name, /// using the value supplied. This value is converted to an /// <see cref="InjectionParameterValue"/> object using the /// rules defined by the <see cref="InjectionParameterValue.ToParameters"/> /// method. /// </summary> /// <param name="propertyName">Name of property to inject.</param> /// <param name="propertyValue">Value for property.</param> public InjectionProperty(string propertyName, object propertyValue) { this.propertyName = propertyName; this.parameterValue = InjectionParameterValue.ToParameter(propertyValue); }
/// <summary> /// Construct a new <see cref="ParameterOverride"/> object that will /// override the given named constructor parameter, and pass the given /// value. /// </summary> /// <param name="parameterName">Name of the constructor parameter.</param> /// <param name="parameterValue">Value to pass for the constructor.</param> public ParameterOverride(string parameterName, object parameterValue) { this.parameterName = parameterName; this.parameterValue = InjectionParameterValue.ToParameter(parameterValue); }