/*----------------------------------------------------------------------------------------*/
/// <summary>
/// Creates an injection directive for the specified property.
/// </summary>
/// <param name="binding">The binding.</param>
/// <param name="property">The property to create the directive for.</param>
/// <returns>The created directive.</returns>
public PropertyInjectionDirective Create(IBinding binding, PropertyInfo property)
{
var directive = new PropertyInjectionDirective(property);
directive.Argument = CreateArgument(binding, new PropertyTarget(property));
return directive;
}
/*----------------------------------------------------------------------------------------*/
/// <summary>
/// Creates an injection directive for the specified property.
/// </summary>
/// <param name="binding">The binding.</param>
/// <param name="property">The property to create the directive for.</param>
/// <returns>The created directive.</returns>
public PropertyInjectionDirective Create(IBinding binding, PropertyInfo property)
{
var directive = new PropertyInjectionDirective(property);
directive.Argument = CreateArgument(binding, new PropertyTarget(property));
return(directive);
}
public void CreatesTargetForProperty()
{
var method = typeof(Dummy).GetProperty("Foo");
PropertyInjector injector = delegate { };
directive = new PropertyInjectionDirective(method, injector);
directive.Target.Name.ShouldBe("Foo");
directive.Target.Type.ShouldBe(typeof(int));
}
public PlanTests()
{
_constructor1 = CreateConstructorInjectionDirective();
_constructor2 = CreateConstructorInjectionDirective();
_property = CreatePropertyInjectionDirective();
_plan = new Plan(this.GetType());
_plan.Add(_constructor1);
_plan.Add(_property);
_plan.Add(_constructor2);
}
public void CreatesTargetForProperty()
{
#if !WINRT
var method = typeof(Dummy).GetProperty("Foo");
#else
var method = typeof(Dummy).GetRuntimeProperty("Foo");
#endif
PropertyInjector injector = delegate { };
directive = new PropertyInjectionDirective(method, injector);
directive.Target.Name.Should().Be("Foo");
directive.Target.Type.Should().Be(typeof(int));
}
/// <summary>
/// Applies user supplied override values to instance properties.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="reference">A reference to the instance being activated.</param>
/// <param name="propertyValues">The parameter override value accessors.</param>
/// <exception cref="ActivationException">A given <see cref="IPropertyValue"/> cannot be resolved to a property of the specified instance.</exception>
private void AssignPropertyOverrides(IContext context, InstanceReference reference, List <IPropertyValue> propertyValues)
{
var properties = reference.Instance.GetType().GetProperties(this.Flags);
foreach (var propertyValue in propertyValues)
{
var propertyInfo = FindPropertyByName(properties, propertyValue.Name, StringComparison.Ordinal);
if (propertyInfo == null)
{
throw new ActivationException(this.exceptionFormatter.CouldNotResolvePropertyForValueInjection(context.Request, propertyValue.Name));
}
var target = new PropertyInjectionDirective(propertyInfo, this.injectorFactory.Create(propertyInfo));
var value = propertyValue.GetValue(context, target.Target);
target.Injector(reference.Instance, value);
}
}
/// <summary>
/// Applies user supplied override values to instance properties.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="reference">A reference to the instance being activated.</param>
/// <param name="propertyValues">The parameter override value accessors.</param>
private void AssignPropertyOverrides(IContext context, InstanceReference reference, IList <IPropertyValue> propertyValues)
{
var properties = reference.Instance.GetType().GetRuntimeProperties().FilterPublic(Settings.InjectNonPublic);
foreach (var propertyValue in propertyValues)
{
string propertyName = propertyValue.Name;
var propertyInfo = properties.FirstOrDefault(property => string.Equals(property.Name, propertyName, StringComparison.Ordinal));
if (propertyInfo == null)
{
throw new ActivationException(ExceptionFormatter.CouldNotResolvePropertyForValueInjection(context.Request, propertyName));
}
var target = new PropertyInjectionDirective(propertyInfo, this.InjectorFactory.Create(propertyInfo));
object value = this.GetValue(context, target.Target, propertyValues);
target.Injector(reference.Instance, value);
}
}
/// <summary>
/// Applies user supplied override values to instance properties.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="reference">A reference to the instance being activated.</param>
/// <param name="propertyValues">The parameter ovverride value accessors.</param>
private void AssignProperyOverrides(IContext context, InstanceReference reference, IEnumerable <IParameter> propertyValues)
{
var properties = reference.Instance.GetType().GetProperties(Flags);
foreach (var propertyValue in propertyValues)
{
string propertyName = propertyValue.Name;
var propertyInfo = properties
.Where(property => string.Equals(property.Name, propertyName, StringComparison.Ordinal))
.FirstOrDefault();
if (propertyInfo == null)
{
throw new ActivationException(ExceptionFormatter.CouldNotResolveProperyForValueInjection(context.Request, propertyName));
}
var target = new PropertyInjectionDirective(propertyInfo, InjectorFactory.Create(propertyInfo));
object value = GetValue(context, target.Target);
target.Injector(reference.Instance, value);
}
}
/// <summary>
/// Injects values into the properties as described by <see cref="PropertyInjectionDirective"/>s
/// contained in the plan.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="reference">A reference to the instance being activated.</param>
public override void Activate(IContext context, InstanceReference reference)
{
Ensure.ArgumentNotNull(context, "context");
Ensure.ArgumentNotNull(reference, "reference");
var propertyValues = context.Parameters.Where(parameter => parameter is PropertyValue);
IEnumerable <string> parameterNames = propertyValues.Select(parameter => parameter.Name);
foreach (var directive in context.Plan.GetAll <PropertyInjectionDirective>())
{
PropertyInjectionDirective propertyInjectionDirective = directive;
if (parameterNames.Any(name => string.Equals(name, propertyInjectionDirective)))
{
continue;
}
object value = GetValue(context, directive.Target);
directive.Injector(reference.Instance, value);
}
AssignProperyOverrides(context, reference, propertyValues);
}
/*----------------------------------------------------------------------------------------*/
/// <summary>
/// Adds an injection directive related to the specified member to the specified activation plan.
/// </summary>
/// <param name="binding">The binding that points at the type being inspected.</param>
/// <param name="type">The type that is being inspected.</param>
/// <param name="plan">The activation plan to add the directive to.</param>
/// <param name="member">The member to create a directive for.</param>
protected override void AddInjectionDirective(IBinding binding, Type type, IActivationPlan plan, PropertyInfo member)
{
PropertyInjectionDirective directive = binding.Components.DirectiveFactory.Create(binding, member);
plan.Directives.Add(directive);
}
