/// <summary>
/// Implements the <see cref="IContainerConfig.Configure(Container, IRootTargetContainer)"/> method,
/// registering all the targets necessary to use expression-based compilation for all the standard targets
/// defined in the <c>Rezolver</c> core library.
/// </summary>
/// <param name="container">The container - ignored.</param>
/// <param name="targets">Required - the target container into which the various targets will be registered.</param>
/// <remarks>All targets registered by this function are <see cref="ObjectTarget"/> targets backed by concrete instances
/// of the various components (compiler etc).</remarks>
public virtual void Configure(Container container, IRootTargetContainer targets)
{
if (targets == null)
{
throw new ArgumentNullException(nameof(targets));
}
// note - the singleton container is done like this because the expression compiler which uses
// it Resolves it from the container during compilation. This is to ensure that each container
// gets the same singleton container (including OverridingContainer), rather than a single shared one
// from the target container option.
targets.RegisterObject(new SingletonTarget.SingletonContainer());
// targets.RegisterObject(new ExpressionBuilderCache(container));
// will be how containers pick up and use this compiler
targets.SetOption <ITargetCompiler>(ExpressionCompiler.Default);
// if you're looking to re-enter the compilation process for a particular
// target - then you should request our compiler via the type IExpressionCompiler
targets.SetOption <IExpressionCompiler>(ExpressionCompiler.Default);
// loop through all the types in the core Rezolver assembly's Rezolver.Targets namespace, searching for an implementing
// type in this assembly
foreach (var registration in GetStandardTargetBuilders())
{
targets.SetOption(registration.Instance, registration.TargetType);
}
}
public EnumerableTargetContainer(IRootTargetContainer root)
: base(root, typeof(IEnumerable <>))
{
this._tracker = root.GetOption <TargetOrderTracker>();
if (this._tracker == null)
{
// this is the first enumerable container in the root
// so create the tracker and register our own event handler
// for adding enumerable types.
root.SetOption(this._tracker = new TargetOrderTracker(Root));
Root.TargetRegistered += Root_TargetRegistered;
}
}
/// <summary>
/// Implements the <see cref="OptionDependentConfigBase.Configure(IRootTargetContainer)"/> abstract method
/// by configuring the passed <paramref name="targets"/> so it can produce targets for any array type, regardless
/// of whether a single object has been registered for the array's element type.
///
/// After enabling, the ability to register specific targets for concrete array types will still be present.
/// </summary>
/// <param name="targets"></param>
public override void Configure(IRootTargetContainer targets)
{
if (targets == null)
{
throw new ArgumentNullException(nameof(targets));
}
// REVIEW: should this also check that EnableEnumerableInjection is true?
// At the moment, it's just dependent upon the Enumerable config; but it actually needs it to
// be *enabled* too.
if (!targets.GetOption(Options.EnableArrayInjection.Default))
{
return;
}
targets.RegisterContainer(typeof(Array), new ArrayTargetContainer(targets));
targets.SetOption <ITargetContainerTypeResolver, Array>(ArrayTypeResolver.Instance);
}