/*----------------------------------------------------------------------------------------*/
/// <summary>
/// Executed when the instance is being initialized.
/// </summary>
/// <param name="context">The activation context.</param>
/// <returns>A value indicating whether to proceed or stop the execution of the strategy chain.</returns>
public override StrategyResult Initialize(IContext context)
{
IList <FieldInjectionDirective> directives = context.Plan.Directives.GetAll <FieldInjectionDirective>();
if (directives.Count > 0)
{
var contextFactory = context.Binding.Components.ContextFactory;
var injectorFactory = context.Binding.Components.InjectorFactory;
var converter = context.Binding.Components.Converter;
foreach (FieldInjectionDirective directive in directives)
{
// Create a new context in which the field's value will be activated.
IContext injectionContext = contextFactory.CreateChild(context,
directive.Member, directive.Target, directive.Argument.Optional);
// Resolve the value to inject into the field.
object value = directive.Argument.Resolver.Resolve(context, injectionContext);
// Convert the value if necessary.
if (!converter.Convert(value, directive.Target.Type, out value))
{
throw new ActivationException(ExceptionFormatter.CouldNotConvertValueForInjection(context, directive.Target, value));
}
// Get an injector that can inject the value.
IFieldInjector injector = injectorFactory.GetInjector(directive.Member);
// Inject the value.
injector.Set(context.Instance, value);
}
}
return(StrategyResult.Proceed);
}
public void CanCreateFieldInjector()
{
FieldInfo field =
typeof(PropertyAndFieldInvocationObject).GetField("_message", BindingFlags.NonPublic | BindingFlags.Instance);
IFieldInjector injector = Factory.GetInjector(field);
Assert.That(injector, Is.Not.Null);
}
public void FieldInjectorCanSetReferenceType()
{
FieldInfo field =
typeof(PropertyAndFieldInvocationObject).GetField("_message", BindingFlags.NonPublic | BindingFlags.Instance);
IFieldInjector injector = Factory.GetInjector(field);
Assert.That(injector, Is.Not.Null);
PropertyAndFieldInvocationObject mock = new PropertyAndFieldInvocationObject();
injector.Set(mock, "Hello, world!");
Assert.That(mock.Message, Is.EqualTo("Hello, world!"));
}
public void FieldInjectorCanSetValueType()
{
FieldInfo field =
typeof(PropertyAndFieldInvocationObject).GetField("_value", BindingFlags.NonPublic | BindingFlags.Instance);
IFieldInjector injector = Factory.GetInjector(field);
Assert.That(injector, Is.Not.Null);
PropertyAndFieldInvocationObject mock = new PropertyAndFieldInvocationObject();
injector.Set(mock, 42);
Assert.That(mock.Value, Is.EqualTo(42));
}
/*----------------------------------------------------------------------------------------*/
/// <summary>
/// Gets an injector for the specified field.
/// </summary>
/// <param name="field">The field that the injector will read and write.</param>
/// <returns>A new injector for the field.</returns>
public IFieldInjector GetInjector(FieldInfo field)
{
lock (_fieldInjectors)
{
if (_fieldInjectors.ContainsKey(field))
{
return(_fieldInjectors[field]);
}
IFieldInjector injector = CreateInjector(field);
_fieldInjectors.Add(field, injector);
return(injector);
}
}
/// <summary>
/// Injects values into fields of the child class using information from the specified
/// configuration file.
/// </summary>
/// <param name="configurationFile">The file that contains the values used to populate the fields</param>
public void InjectFields(String configurationFile)
{
XmlTextReader reader =
new XmlTextReader(@configurationFile);
FieldInjectorRepository fieldInjectorRepository = new FieldInjectorRepository();
while (reader.Read() == true)
{
FieldInfo fieldInfo = GetFieldInfoFor(this.GetMojoImplementationType(), reader.Name);
if (fieldInfo != null)
{
IFieldInjector fieldInjector = fieldInjectorRepository.getFieldInjectorFor(fieldInfo);
fieldInjector.Inject(this, fieldInfo, reader.ReadString());
}
}
}
