private InjectionParameterValue InitializeParameterValue(PropertyInfo propInfo)
{
if(parameterValue == null)
{
parameterValue = new ResolvedParameter(propInfo.PropertyType);
}
return parameterValue;
}
private static void GuardPropertyValueIsCompatible(PropertyInfo property, InjectionParameterValue value)
{
if (!value.MatchesType(property.PropertyType))
{
throw new InvalidOperationException(
ExceptionMessage(Resources.PropertyTypeMismatch,
property.Name,
property.DeclaringType,
property.PropertyType,
value.ParameterTypeName));
}
}
/// <summary>
/// Convert an arbitrary value to an InjectionParameterValue object. The rules are:
/// If it's already an InjectionParameterValue, return it. If it's a Type, return a
/// ResolvedParameter object for that type. Otherwise return an InjectionParameter
/// object for that value.
/// </summary>
/// <param name="value">The value to convert.</param>
/// <returns>The resulting <see cref="InjectionParameterValue"/>.</returns>
public static InjectionParameterValue ToParameter(object value)
{
InjectionParameterValue parameterValue = value as InjectionParameterValue;
if (parameterValue != null)
{
return(parameterValue);
}
Type typeValue = value as Type;
if (typeValue != null)
{
return(new ResolvedParameter(typeValue));
}
return(new InjectionParameter(value));
}
/// <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>
/// Construct a new <see cref="ResolvedArrayParameter"/> that
/// resolves to the given array and element types and collection of element values.
/// </summary>
/// <param name="arrayParameterType">The type for the array of elements to resolve.</param>
/// <param name="elementType">The type of elements to resolve.</param>
/// <param name="elementValues">The values for the elements, that will
/// be converted to <see cref="InjectionParameterValue"/> objects.</param>
protected ResolvedArrayParameter(Type arrayParameterType, Type elementType, params object[] elementValues)
: base(arrayParameterType)
{
Guard.ArgumentNotNull(elementType, "elementType");
Guard.ArgumentNotNull(elementValues, "elementValues");
this.elementType = elementType;
this.elementValues.AddRange(InjectionParameterValue.ToParameters(elementValues));
foreach (InjectionParameterValue pv in this.elementValues)
{
if (!pv.MatchesType(elementType))
{
throw new InvalidOperationException(
string.Format(
CultureInfo.CurrentCulture,
Resources.TypesAreNotAssignable,
elementType,
pv.ParameterTypeName));
}
}
}
/// <summary>
/// Constructs a new <see cref="ResourceInjectionValue"/> with an <see cref="InjectionParameterValue"/>.
/// </summary>
/// <param name="injectionParameterValue"><see cref="InjectionParameterValue"/> that resolves to a resource URI</param>
/// <param name="many">true if there can be several resources; false if only one is expected</param>
public ResourceInjectionValue(InjectionParameterValue injectionParameterValue, bool many = false)
: base(many ? typeof(IList<IResource>) : typeof(IResource))
{
_injectionParameterValue = injectionParameterValue;
_many = many;
}
/// <summary>
/// Constructs a new <see cref="ResourceInjectionValue"/> with a string URI.
/// </summary>
/// <param name="uri">a string representing a resource</param>
/// <param name="many">true if there can be several resources; false if only one is expected</param>
public ResourceInjectionValue(string uri, bool many = false)
: base(many ? typeof(IList<IResource>) : typeof(IResource))
{
_injectionParameterValue = new LateBindingInjectionValue<string>(uri);
_many = many;
}
/// <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);
}
public SpecifiedConstructorSelectorPolicy(ConstructorInfo ctor, InjectionParameterValue[] parameterValues)
{
this.ctor = ctor;
ctorReflector = new MethodReflectionHelper(ctor);
this.parameterValues = parameterValues;
}
/// <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);
}
/// <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);
}
/// <summary>
/// Create an instance of <see cref="SpecifiedConstructorSelectorPolicy"/> that
/// will return the given constructor, being passed the given injection values
/// as parameters.
/// </summary>
/// <param name="ctor">The constructor to call.</param>
/// <param name="parameterValues">Set of <see cref="InjectionParameterValue"/> objects
/// that describes how to obtain the values for the constructor parameters.</param>
public SpecifiedConstructorSelectorPolicy(ConstructorInfo ctor, InjectionParameterValue[] parameterValues)
{
this.ctor = ctor;
this.parameterValues = parameterValues;
}
protected override void VisitEnumerableParameterValue(ContainerResolvedEnumerableParameter parameterValue)
{
var resolveParameters = parameterValue.Names
.Select(name => new ResolvedParameter(parameterValue.ElementType, name))
.ToArray();
InjectionParameter = new ResolvedArrayParameter(parameterValue.ElementType, resolveParameters);
}
protected override void VisitResolvedParameterValue(ContainerResolvedParameter parameterValue)
{
InjectionParameter = new ResolvedParameter(parameterValue.Type, parameterValue.Name);
}
protected override void VisitConstantParameterValue(ConstantParameterValue parameterValue)
{
this.InjectionParameter = new InjectionParameter(parameterValue.Type, parameterValue.Value);
}
/// <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>
/// Create a new <see cref="InjectionMethod"/> instance which will configure
/// the container to call the given methods with the given parameters.
/// </summary>
/// <param name="methodName">Name of the method to call.</param>
/// <param name="methodParameters">Parameter values for the method.</param>
public InjectionMethod(string methodName, params object[] methodParameters)
{
this.methodName = methodName;
this.methodParameters = InjectionParameterValue.ToParameters(methodParameters).ToList();
}
private static void GuardPropertyValueIsCompatible(PropertyInfo property, InjectionParameterValue value)
{
if (!value.MatchesType(property.PropertyType))
{
throw new InvalidOperationException();
}
}
/// <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 AutowireEnabledInjectionProperty(string propertyName, object propertyValue)
{
this.propertyName = propertyName;
parameterValue = InjectionParameterValue.ToParameter(propertyValue);
}
/// <summary>
/// Create a new instance of <see cref="InjectionConstructor"/> that looks
/// for a constructor with the given set of parameters.
/// </summary>
/// <param name="parameterValues">The values for the parameters, that will
/// be converted to <see cref="InjectionParameterValue"/> objects.</param>
public InjectionConstructor(params object[] parameterValues)
{
this.parameterValues = Sequence.ToList(InjectionParameterValue.ToParameters(parameterValues));
}
private static void GuardPropertyValueIsCompatible(PropertyInfo property, InjectionParameterValue value)
{
if (!value.MatchesType(property.PropertyType))
{
throw new InvalidOperationException(
ExceptionMessage(Resources.PropertyTypeMismatch,
property.Name,
property.DeclaringType,
property.PropertyType,
value.ParameterTypeName));
}
}
/// <summary>
/// Add a property that will be par of the set returned when the
/// <see cref="SelectProperties(IBuilderContext, IPolicyList)"/> is called.
/// </summary>
/// <param name="property">The property to set.</param>
/// <param name="value"><see cref="InjectionParameterValue"/> object describing
/// how to create the value to inject.</param>
public void AddPropertyAndValue(PropertyInfo property, InjectionParameterValue value)
{
propertiesAndValues.Add(Pair.Make(property, value));
}
/// <summary>
/// Create a new instance of <see cref="InjectionConstructor"/> that looks
/// for a constructor with the given set of parameters.
/// </summary>
/// <param name="parameterValues">The values for the parameters, that will
/// be converted to <see cref="InjectionParameterValue"/> objects.</param>
public InjectionConstructorRelaxed(params object[] parameterValues)
{
_parameterValues = InjectionParameterValue.ToParameters(parameterValues).ToList();
}
/// <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>
/// Create an instance of <see cref="PropertyOverride"/>.
///</summary>
///<param name="propertyName">The property name.</param>
///<param name="propertyValue">Value to use for the property.</param>
public PropertyOverride(string propertyName, object propertyValue)
{
this.propertyName = propertyName;
this.propertyValue = InjectionParameterValue.ToParameter(propertyValue);
}
private InjectionParameterValue InitializeParameterValue(PropertyInfo propInfo)
{
return parameterValue ?? (parameterValue = new ResolvedParameter(propInfo.PropertyType));
}