/// <summary>
/// Configure the component so that any properties whose types are registered in the
/// container will be wired to instances of the appropriate service.
/// </summary>
/// <param name="wiringFlags">Set wiring options such as circular dependency wiring support.</param>
/// <returns>A registration builder allowing further configuration of the component.</returns>
public IRegistrationBuilder <TLimit, TActivatorData, TRegistrationStyle> PropertiesAutowired(PropertyWiringFlags wiringFlags)
{
var injector = new AutowiringPropertyInjector();
var allowCircularDependencies = 0 != (int)(wiringFlags & PropertyWiringFlags.AllowCircularDependencies);
var preserveSetValues = 0 != (int)(wiringFlags & PropertyWiringFlags.PreserveSetValues);
if (allowCircularDependencies)
{
RegistrationData.ActivatedHandlers.Add((s, e) => injector.InjectProperties(e.Context, e.Instance, !preserveSetValues));
}
else
{
RegistrationData.ActivatingHandlers.Add((s, e) => injector.InjectProperties(e.Context, e.Instance, !preserveSetValues));
}
return(this);
}
public IRegistrationBuilder <TLimit, TActivatorData, TRegistrationStyle> PropertiesAutowired(PropertyWiringFlags wiringFlags)
{
AutowiringPropertyInjector injector = new AutowiringPropertyInjector();
bool flag = PropertyWiringFlags.Default != (wiringFlags & PropertyWiringFlags.AllowCircularDependencies);
bool preserveSetValues = PropertyWiringFlags.Default != (wiringFlags & PropertyWiringFlags.PreserveSetValues);
if (flag)
{
this.RegistrationData.ActivatedHandlers.Add(delegate(object s, ActivatedEventArgs <object> e) {
injector.InjectProperties(e.Context, e.Instance, !preserveSetValues);
});
}
else
{
this.RegistrationData.ActivatingHandlers.Add(delegate(object s, ActivatingEventArgs <object> e) {
injector.InjectProperties(e.Context, e.Instance, !preserveSetValues);
});
}
return(this);
}
public void NullCheckTests()
{
var ctx = new ContainerBuilder().Build();
var instance = new object();
var propertySelector = new DefaultPropertySelector(true);
var parameters = new Parameter[0];
Assert.Throws <ArgumentNullException>(() => AutowiringPropertyInjector.InjectProperties(null, instance, propertySelector, parameters));
Assert.Throws <ArgumentNullException>(() => AutowiringPropertyInjector.InjectProperties(ctx, null, propertySelector, parameters));
Assert.Throws <ArgumentNullException>(() => AutowiringPropertyInjector.InjectProperties(ctx, instance, null, parameters));
Assert.Throws <ArgumentNullException>(() => AutowiringPropertyInjector.InjectProperties(ctx, instance, propertySelector, null));
}
/// <summary>
/// Configure the component so that any properties whose types are registered in the
/// container and follow specific criteria will be wired to instances of the appropriate service.
/// </summary>
/// <param name="propertySelector">Selector to determine which properties should be injected.</param>
/// <param name="allowCircularDependencies">Determine if circular dependencies should be allowed or not.</param>
/// <returns>A registration builder allowing further configuration of the component.</returns>
public IRegistrationBuilder <TLimit, TActivatorData, TRegistrationStyle> PropertiesAutowired(IPropertySelector propertySelector, bool allowCircularDependencies)
{
if (allowCircularDependencies)
{
RegistrationData.ActivatedHandlers.Add((s, e) => AutowiringPropertyInjector.InjectProperties(e.Context, e.Instance, propertySelector, e.Parameters));
}
else
{
RegistrationData.ActivatingHandlers.Add((s, e) => AutowiringPropertyInjector.InjectProperties(e.Context, e.Instance, propertySelector, e.Parameters));
}
return(this);
}
/// <summary>
/// Set any null-valued properties on <paramref name="instance"/> that can be
/// resolved by the container.
/// </summary>
/// <typeparam name="TService">Type of instance. Used only to provide method chaining.</typeparam>
/// <param name="context">The context from which to resolve the service.</param>
/// <param name="instance">The instance to inject properties into.</param>
/// <returns><paramref name="instance"/>.</returns>
public static TService InjectUnsetProperties <TService>(this IComponentContext context, TService instance)
{
AutowiringPropertyInjector.InjectProperties(context, instance, DefaultPropertySelector.PreserveSetValueInstance);
return(instance);
}
/// <summary>
/// Set any properties on <paramref name="instance"/> that can be resolved by service and that satisfy the
/// constraints imposed by <paramref name="propertySelector"/>
/// </summary>
/// <typeparam name="TService">Type of instance. Used only to provide method chaining.</typeparam>
/// <param name="context">The context from which to resolve the service.</param>
/// <param name="instance">The instance to inject properties into.</param>
/// <param name="propertySelector">Selector to determine with properties should be injected.</param>
/// <returns><paramref name="instance"/>.</returns>
public static TService InjectProperties <TService>(this IComponentContext context, TService instance, IPropertySelector propertySelector)
{
AutowiringPropertyInjector.InjectProperties(context, instance, propertySelector);
return(instance);
}
/// <summary>
/// Set any null-valued properties on <paramref name="instance"/> that can be
/// resolved by the container.
/// </summary>
/// <typeparam name="TService">Type of instance. Used only to provide method chaining.</typeparam>
/// <param name="context">The context from which to resolve the service.</param>
/// <param name="instance">The instance to inject properties into.</param>
/// <returns><paramref name="instance"/>.</returns>
public static TService InjectUnsetProperties <TService>(this IComponentContext context, TService instance)
{
AutowiringPropertyInjector.InjectProperties(context, instance, false);
return(instance);
}
