/// <summary>
/// Creates a <see cref="ConstructorTarget"/> or <see cref="GenericConstructorTarget"/>
/// for the type <paramref name="type"/>.
/// </summary>
/// <param name="type">The type whose constructor is to be bound by the target.</param>
/// <param name="namedArgs">Optional. A dictionary of targets that are to be bound to the type's
/// constructor by name and type. If <paramref name="type"/> is a generic type definition, then
/// this parameter must be null, or an <see cref="ArgumentException"/> will be thrown.</param>
/// <param name="memberBinding">Optional - provides an explicit member injection behaviour to be used when creating the instance,
/// if different from the behaviour configured via options on any target container in which the target is subsequently registered.</param>
/// <returns>A new target for the type <paramref name="type"/></returns>
/// <remarks>If the type is a generic type definition, then a <see cref="GenericConstructorTarget"/>
/// is created; otherwise a <see cref="ConstructorTarget"/> is created.</remarks>
public static ITarget ForType(
Type type,
IDictionary <string, ITarget> namedArgs,
IMemberBindingBehaviour memberBinding = null)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (type.IsGenericTypeDefinition)
{
// can't pass named arguments if the type is generic, because there's no reliable
// way to guarantee that the arguments can actually be bound at the moment.
// once we have conditional targets, then perhaps.
if (namedArgs?.Count > 0)
{
throw new ArgumentException("Cannot use namedArguments with a generic type", nameof(namedArgs));
}
return(new GenericConstructorTarget(type, memberBinding));
}
return(new ConstructorTarget(type, namedArgs, memberBinding));
}
/// <summary>
/// Creates a <see cref="ConstructorTarget"/> or <see cref="GenericConstructorTarget"/>
/// for the type <paramref name="type"/>.
/// </summary>
/// <param name="type">The type whose constructor is to be bound by the target.</param>
/// <param name="namedArgs">Optional. An object whose publicly readable members which are of the
/// type <see cref="ITarget"/> (or a type which implements it) are to be bound to the type's constructor
/// by name and <see cref="ITarget.DeclaredType"/>.
///
/// If <paramref name="type"/> is a generic type definition, then
/// this parameter must be null, or an <see cref="ArgumentException"/> will be thrown.</param>
/// <param name="memberBinding">Optional - provides an explicit member injection behaviour to be used when creating the instance,
/// if different from the behaviour configured via options on any target container in which the target is subsequently registered.</param>
/// <remarks>If the type is a generic type definition, then a <see cref="GenericConstructorTarget"/>
/// is created; otherwise a <see cref="ConstructorTarget"/> is created.
/// </remarks>
/// <example>This example shows how to provide an ObjectTarget for the parameter 'param1' when creating a
/// ConstructorTarget for the type 'MyType':
/// <code>Target.ForType(typeof(MyType), namedArguments: new { param1 = new ObjectTarget(" Hello World") });</code>
/// </example>
public static ITarget ForType(
Type type,
object namedArgs,
IMemberBindingBehaviour memberBinding = null)
{
return(ForType(type, namedArgs.ToMemberValueDictionary <ITarget>(), memberBinding));
}
/// <summary>
/// Registers a type by constructor alone.
/// </summary>
/// <param name="targets"></param>
/// <param name="constructor">The constructor to be bound. The <see cref="MemberInfo.DeclaringType"/> will be used
/// as the service type to be registered against.</param>
/// <param name="memberBindingBehaviour">Optional. If you wish to bind members on the new instance, passing a member binding
/// behaviour here.</param>
/// <remarks>If the <paramref name="constructor"/> belongs to an open generic type, then a <see cref="Targets.GenericConstructorTarget"/>
/// will be created and registered.</remarks>
public static void RegisterConstructor(
this ITargetContainer targets,
ConstructorInfo constructor,
IMemberBindingBehaviour memberBindingBehaviour = null)
{
if (targets == null)
{
throw new ArgumentNullException(nameof(targets));
}
targets.Register(Target.ForConstructor(constructor ?? throw new ArgumentNullException(nameof(constructor)), memberBindingBehaviour));
}
/// <summary>
/// Creates and registers a target bound to the constructor of a generic type definition using the
/// <see cref="Target.ForGenericConstructor{TExample}(Expression{Func{TExample}}, IMemberBindingBehaviour)"/> factory method.
///
/// See the documentation on that method for more.
///
/// The registration will be made against the open generic type.
/// </summary>
/// <typeparam name="TExample">Must be a generic type which represents a concrete generic whose generic type definition will be
/// bound by the created target. This type is also used as the service type for the registration.</typeparam>
/// <param name="targets">The container into which the registration will be made.</param>
/// <param name="newExpr">Exemplar expression which is used to identify the constructor to be bound.</param>
/// <param name="memberBindingBehaviour">A member binding behaviour to be passed to the created target</param>
/// <seealso cref="Target.ForGenericConstructor{TExample}(Expression{Func{TExample}}, IMemberBindingBehaviour)"/>
public static void RegisterGenericConstructor <TExample>(
this ITargetContainer targets,
Expression <Func <TExample> > newExpr,
IMemberBindingBehaviour memberBindingBehaviour = null)
{
if (targets == null)
{
throw new ArgumentNullException(nameof(targets));
}
targets.Register(Target.ForGenericConstructor(newExpr, memberBindingBehaviour));
}
/// <summary>
/// Same as <see cref="RegisterGenericConstructor{TObject}(ITargetContainer, Expression{Func{TObject}}, IMemberBindingBehaviour)"/>
/// except this creates the target and then registers it against a generic base or interface of the generic type definition identified
/// from <typeparamref name="TExampleService"/>.
/// </summary>
/// <typeparam name="TExample">Must be a generic type which represents a concrete generic whose generic type definition will be
/// bound by the target that is created and registered. The type must inherit or implement the type <typeparamref name="TExampleService"/>.</typeparam>
/// <typeparam name="TExampleService">Must be a generic type that is a base or interface of <typeparamref name="TExample"/>. The registration will
/// be made against this type's generic type definition.</typeparam>
/// <param name="targets">The container into which the registration will be made.</param>
/// <param name="newExpr">Exemplar expression which is used to identify the constructor to be bound.</param>
/// <param name="memberBindingBehaviour">A member binding behaviour to be passed to the created target</param>
/// <seealso cref="Target.ForGenericConstructor{TExample}(Expression{Func{TExample}}, IMemberBindingBehaviour)"/>
public static void RegisterGenericConstructor <TExample, TExampleService>(
this ITargetContainer targets,
Expression <Func <TExample> > newExpr,
IMemberBindingBehaviour memberBindingBehaviour = null)
where TExample : TExampleService
{
if (targets == null)
{
throw new ArgumentNullException(nameof(targets));
}
if (!typeof(TExampleService).IsGenericType)
{
throw new ArgumentException($"Service type {typeof(TExampleService)} is not a generic type", nameof(TExampleService));
}
targets.Register(Target.ForGenericConstructor(newExpr, memberBindingBehaviour), typeof(TExampleService).GetGenericTypeDefinition());
}
/// <summary>
/// Creates a target which binds to the constructor of an open generic type, an exemplar of which is passed in <paramref name="newExpr"/>.
///
/// The created target will be <see cref="Targets.GenericConstructorTarget"/> whose <see cref="Targets.GenericConstructorTarget.GenericTypeConstructor"/>
/// will be set to the constructor that is identified from the expression.
/// </summary>
/// <typeparam name="TExample">Must be a generic type. It doesn't matter what the type arguments are, however,
/// as the target that is created will be for the generic type definition of this type.</typeparam>
/// <param name="newExpr">A lambda expression whose <see cref="LambdaExpression.Body"/> is a <see cref="NewExpression"/>
/// which identifies the constructor that is to be used to create the instance of all concrete types derived from the
/// the same generic type definition as <typeparamref name="TExample"/>.</param>
/// <param name="memberBindingBehaviour">Optional. If you wish to bind members on the new instance, pass a member binding
/// behaviour here.</param>
/// <remarks>Note - a concrete generic is used as an *example* - the equivalent open generic constructor is located
/// and registered against the open generic of the type you actually invoke this method for; e.g. if
/// <typeparamref name="TExample"/> is `MyGeneric<Foo, Bar>`, then a target bound to the equivalent
/// constructor on the open generic `MyGeneric<,>` will be what is actually created.</remarks>
public static ITarget ForGenericConstructor <TExample>(
Expression <Func <TExample> > newExpr,
IMemberBindingBehaviour memberBindingBehaviour = null)
{
if (!typeof(TExample).IsGenericType)
{
throw new ArgumentException($"{typeof(TExample)} is not a generic type.");
}
var ctor = Extract.GenericConstructor(newExpr ?? throw new ArgumentNullException(nameof(newExpr)));
if (ctor == null)
{
throw new ArgumentException($"The expression ${newExpr} does not represent a NewExpression invoking a generic type's constructor.", nameof(newExpr));
}
return(ForConstructor(ctor, memberBindingBehaviour));
}
/// <summary>
/// Register a type by constructor (represented by the expression <paramref name="newExpr"/>).
/// </summary>
/// <typeparam name="TObject"></typeparam>
/// <param name="targets"></param>
/// <param name="newExpr">A lambda expression whose <see cref="LambdaExpression.Body"/> is a <see cref="NewExpression"/>
/// which identifies the constructor that is to be used to create the instance of <typeparamref name="TObject"/>.</param>
/// <param name="memberBindingBehaviour">Optional. If you wish to bind members on the new instance, passing a member binding
/// behaviour here.</param>
/// <remarks>Note that you can achieve a similar result by simply registering an expression which
/// represents a call to a type's constructor.</remarks>
public static void RegisterConstructor <TObject>(
this ITargetContainer targets,
Expression <Func <TObject> > newExpr,
IMemberBindingBehaviour memberBindingBehaviour = null)
{
if (targets == null)
{
throw new ArgumentNullException(nameof(targets));
}
var ctor = Extract.Constructor(newExpr ?? throw new ArgumentNullException(nameof(newExpr)));
if (ctor == null)
{
throw new ArgumentException($"The expression ${newExpr} does not represent a NewExpression", nameof(newExpr));
}
targets.Register(Target.ForConstructor(ctor, memberBindingBehaviour));
}
private ConstructorTarget(Type type,
ConstructorInfo ctor,
IMemberBindingBehaviour memberBinding,
ParameterBinding[] parameterBindings,
IDictionary <string, ITarget> suppliedArgs)
{
this._ctor = ctor;
DeclaredType = type ?? ctor?.DeclaringType;
if (type != null)
{
if (type.IsInterface || type.IsAbstract)
{
throw new ArgumentException("Type must not be an interface or an abstract class", nameof(type));
}
}
this._parameterBindings = parameterBindings ?? ParameterBinding.None;
MemberBindingBehaviour = memberBinding;
this._namedArgs = suppliedArgs ?? new Dictionary <string, ITarget>();
}
/// <summary>
/// Creates a <see cref="ConstructorTarget"/> for the given constructor, or a <see cref="GenericConstructorTarget"/> if the
/// constructor belongs to a generic type definition ('open generic type').
/// </summary>
/// <param name="constructor">Required. The constructor to be bound by the target.</param>
/// <param name="parameterBindings">Can be null/empty. An array of <see cref="ParameterBinding"/>
/// objects containing targets to be bound to somme or all of the constructor parameters. **Must not be supplied if <paramref name="constructor"/>
/// is a constructor belonging to an open generic type,**</param>
/// <param name="memberBinding">Optional - provides an explicit member injection behaviour to be used when creating the instance,
/// if different from the behaviour configured via options on any target container in which the target is subsequently registered.</param>
public static ITarget ForConstructor(
ConstructorInfo constructor,
ParameterBinding[] parameterBindings,
IMemberBindingBehaviour memberBinding = null)
{
if (constructor == null)
{
throw new ArgumentNullException(nameof(constructor));
}
if (constructor.DeclaringType.IsGenericTypeDefinition)
{
if (parameterBindings?.Length > 0)
{
throw new ArgumentException("You cannot currently supply parameter bindings for generic constructors", nameof(parameterBindings));
}
return(new GenericConstructorTarget(constructor, memberBinding));
}
return(new ConstructorTarget(constructor, parameterBindings, memberBinding));
}
/// <summary>
/// Creates a <see cref="ConstructorTarget"/> for the given constructor, or a <see cref="GenericConstructorTarget"/> if the
/// constructor belongs to a generic type definition ('open generic type').
/// </summary>
/// <param name="constructor">Required. The constructor to be bound by the target.</param>
/// <param name="namedArgs">Optional. An object whose publicly readable members which are of the
/// type <see cref="ITarget"/> (or a type which implements it) are to be bound to the constructor
/// by name and <see cref="ITarget.DeclaredType"/>. **Must not be supplied if <paramref name="constructor"/>
/// is a constructor belonging to an open generic type,**</param>
/// <param name="memberBinding">Optional - provides an explicit member injection behaviour to be used when creating the instance,
/// if different from the behaviour configured via options on any target container in which the target is subsequently registered.</param>
public static ITarget ForConstructor(
ConstructorInfo constructor,
object namedArgs,
IMemberBindingBehaviour memberBinding = null)
{
if (constructor == null)
{
throw new ArgumentNullException(nameof(constructor));
}
if (constructor.DeclaringType.IsGenericTypeDefinition)
{
if (namedArgs != null)
{
throw new ArgumentException("You cannot current supply named argument bindings for open generic constructors", nameof(namedArgs));
}
return(new GenericConstructorTarget(constructor, memberBinding));
}
var bindings = ParameterBinding.BindMethod(constructor, namedArgs.ToMemberValueDictionary <ITarget>());
return(new ConstructorTarget(constructor, bindings, memberBinding));
}
/// <summary>
/// Creates a <see cref="ConstructorTarget"/> or <see cref="GenericConstructorTarget"/>
/// for the type <typeparamref name="T"/>.
/// </summary>
/// <typeparam name="T">The type whose constructor is to be bound by the created target.</typeparam>
/// <param name="namedArgs">Optional. An object whose publicly readable members which are of the
/// type <see cref="ITarget"/> (or a type which implements it) are to be bound to the type's constructor
/// by name and <see cref="ITarget.DeclaredType"/>.</param>
/// <param name="memberBinding">Optional - provides an explicit member injection behaviour to be used when creating the instance,
/// if different from the behaviour configured via options on any target container in which the target is subsequently registered.</param>
/// <returns>A new target for the type <typeparamref name="T"/></returns>
/// <example>This example shows how to provide an ObjectTarget for the parameter 'param1' when creating a
/// ConstructorTarget for the type 'MyType':
/// <code>Target.ForType<MyType>(namedArguments: new { param1 = new ObjectTarget("Hello World") });</code>
/// </example>
public static ITarget ForType <T>(
object namedArgs,
IMemberBindingBehaviour memberBinding = null)
{
return(ForType(typeof(T), namedArgs, memberBinding));
}
/// <summary>
/// Registers the type <typeparamref name="TObject"/> for the service type <typeparamref name="TService"/> to be created by
/// an <see cref="Container"/> via constructor injection.
/// The registration will auto-bind a constructor based on the services available in the <see cref="ITargetContainer"/> and
/// <see cref="Container"/> available at the time <see cref="Container.Resolve(ResolveContext)"/> is first called.
/// </summary>
/// <typeparam name="TObject">The type of the object that is to be constructed when resolved.</typeparam>
/// <typeparam name="TService">The type against which the registration will be performed. <typeparamref name="TObject"/> must be
/// compatible with this type.</typeparam>
/// <param name="targetContainer">The target container on which the registration is to be performed.</param>
/// <param name="memberBinding">Optional - provides an explicit member injection behaviour to be used when creating the instance,
/// if different from the behaviour configured via options on the <paramref name="targetContainer"/>.</param>
/// <remarks>This is equivalent to creating either a <see cref="ConstructorTarget"/> or <see cref="GenericConstructorTarget"/> via
/// the <see cref="Target.ForType{T}(IMemberBindingBehaviour)"/> static method and then registering it against
/// the type <typeparamref name="TService"/>.</remarks>
public static void RegisterType <TObject, TService>(this ITargetContainer targetContainer, IMemberBindingBehaviour memberBinding = null)
where TObject : TService
{
RegisterType(targetContainer, typeof(TObject), serviceType: typeof(TService), memberBinding: memberBinding);
}
/// <summary>
/// Initializes a new instance of the <see cref="ConstructorTarget"/> class bound in advance to a specific constructor.
/// </summary>
/// <param name="ctor">Required - the constructor that is to be bound. The <see cref="DeclaredType"/> of the new instance
/// will be set to the <see cref="MemberInfo.DeclaringType"/> of this object.</param>
/// <param name="parameterBindings">Optional. Specific bindings for the parameters of the given <paramref name="ctor"/>
/// which should be used during code generation. Note that this array can contain fewer or more entries than there are
/// parameters on the <paramref name="ctor"/>. Any missing bindings will be automatically generated when <see cref="Bind(ICompileContext)"/>
/// is called.</param>
/// <param name="memberBinding">Optional - provides an explicit member injection behaviour to be used when creating the instance.
/// If not provided, then the <see cref="Bind(ICompileContext)"/> method will attempt to obtain one via the options API from the
/// <see cref="ICompileContext"/> - and if one is still not available, then no member binding will be performed.</param>
public ConstructorTarget(ConstructorInfo ctor, ParameterBinding[] parameterBindings = null, IMemberBindingBehaviour memberBinding = null)
: this(null, ctor, memberBinding, parameterBindings, null)
{
if (ctor == null)
{
throw new ArgumentNullException(nameof(ctor));
}
}
/// <summary>
/// Registers an explicitly instance of <paramref name="objectType"/> (optionally for the service type <paramref name="serviceType"/>) to be
/// created by an <see cref="Container"/> via constructor injection.
/// The registration will auto-bind a constructor based on the services available in the <see cref="ITargetContainer"/> and
/// <see cref="Container"/> available at the time <see cref="Container.Resolve(ResolveContext)"/> is first called.
/// </summary>
/// <param name="targetContainer">The target container on which the registration is to be performed.</param>
/// <param name="objectType">The type of the object that is to be constructed when resolved.</param>
/// <param name="serviceType">Optional. The type against which the registration will be performed, if different from
/// <paramref name="objectType"/>. <paramref name="objectType"/> must be compatible with this type, if it's provided.</param>
/// <param name="memberBinding">Optional - provides an explicit member injection behaviour to be used when creating the instance,
/// if different from the behaviour configured via options on the <paramref name="targetContainer"/>.</param>
/// <remarks>This is equivalent to creating either a <see cref="ConstructorTarget"/> or <see cref="GenericConstructorTarget"/> via
/// the <see cref="Target.ForType(Type, IMemberBindingBehaviour)"/> static method, wrapping it with a <see cref="ScopedTarget"/>
/// and then registering it against the type <paramref name="serviceType"/> or <paramref name="objectType"/>.</remarks>
public static void RegisterScoped(this ITargetContainer targetContainer, Type objectType, Type serviceType = null, IMemberBindingBehaviour memberBinding = null)
{
if (targetContainer == null)
{
throw new ArgumentNullException(nameof(targetContainer));
}
if (objectType == null)
{
throw new ArgumentNullException(nameof(objectType));
}
RegisterScopedInternal(targetContainer, objectType, serviceType, memberBinding);
}
/// <summary>
/// Creates a <see cref="ConstructorTarget" /> or <see cref="GenericConstructorTarget" />
/// for the type <typeparamref name="T" />.
/// </summary>
/// <typeparam name="T">The type whose constructor is to be bound by the target.</typeparam>
/// <param name="namedArgs">Can be null. A dictionary of targets that are to be bound to the type's
/// constructor by name and <see cref="ITarget.DeclaredType"/>.
///
/// If <typeparamref name="T"/> is a generic type definition, then
/// this parameter must be null, or an <see cref="ArgumentException"/> will be thrown.</param>
/// <param name="memberBinding">Optional - provides an explicit member injection behaviour to be used when creating the instance,
/// if different from the behaviour configured via options on any target container in which the target is subsequently registered.</param>
/// <returns>A new target for the type <typeparamref name="T"/></returns>
public static ITarget ForType <T>(
IDictionary <string, ITarget> namedArgs,
IMemberBindingBehaviour memberBinding = null)
{
return(ForType(typeof(T), namedArgs, memberBinding));
}
/// <summary>
/// Creates a <see cref="ConstructorTarget"/> for the type <typeparamref name="T"/>.
/// </summary>
/// <typeparam name="T">The type whose constructor is to be bound by the target.</typeparam>
/// <param name="memberBinding">Optional - provides an explicit member injection behaviour to be used when creating the instance,
/// if different from the behaviour configured via options on any target container in which the target is subsequently registered.</param>
/// <returns>A new target for the type <typeparamref name="T"/></returns>
public static ITarget ForType <T>(IMemberBindingBehaviour memberBinding = null)
{
return(ForType <T>(namedArgs: null, memberBinding: memberBinding));
}
/// <summary>
/// Registers the type <typeparamref name="TObject"/> as a singleton (<see cref="SingletonTarget"/>) in the target container.
///
/// The instance will be built automatically with constructor injection by leveraging either the <see cref="ConstructorTarget"/> or
/// <see cref="GenericConstructorTarget"/>, depending on whether <typeparamref name="TObject"/> is a generic type or not.
/// </summary>
/// <typeparam name="TObject">The type to be created, and the type against which the registration will be made</typeparam>
/// <param name="targetContainer">The container on which the registrations will be made.</param>
/// <param name="memberBinding">Optional - provides an explicit member injection behaviour to be used when creating the instance,
/// if different from the behaviour configured via options on the <paramref name="targetContainer"/>.</param>
public static void RegisterSingleton <TObject>(this ITargetContainer targetContainer, IMemberBindingBehaviour memberBinding = null)
{
RegisterSingleton(targetContainer, typeof(TObject), memberBinding: memberBinding);
}
internal static void RegisterSingletonInternal(ITargetContainer builder, Type objectType, Type serviceType, IMemberBindingBehaviour memberBinding)
{
builder.Register(Target.ForType(objectType, memberBinding).Singleton(), serviceType: serviceType);
}
/// <summary>
/// Registers an explicitly scoped instance of <typeparamref name="TObject"/> for the service type <typeparamref name="TService"/>
/// to be created by an <see cref="Container"/> via constructor injection.
/// The registration will auto-bind a constructor based on the services available in the <see cref="ITargetContainer"/> and
/// <see cref="Container"/> available at the time <see cref="Container.Resolve(ResolveContext)"/> is first called.
/// </summary>
/// <typeparam name="TObject">The type of the object that is to be constructed when resolved.</typeparam>
/// <typeparam name="TService">The type against which the registration will be performed. <typeparamref name="TObject"/> must be
/// compatible with this type.</typeparam>
/// <param name="targetContainer">The target container on which the registration is to be performed.</param>
/// <param name="memberBinding">Optional - provides an explicit member injection behaviour to be used when creating the instance,
/// if different from the behaviour configured via options on the <paramref name="targetContainer"/>.</param>
/// <remarks>This is equivalent to creating either a <see cref="ConstructorTarget"/> or <see cref="GenericConstructorTarget"/> via
/// the <see cref="Target.ForType{T}(IMemberBindingBehaviour)"/> static method, wrapping it with a
/// <see cref="ScopedTarget"/> and then registering it against
/// the type <typeparamref name="TService"/>.</remarks>
public static void RegisterScoped <TObject, TService>(this ITargetContainer targetContainer, IMemberBindingBehaviour memberBinding = null)
{
RegisterScoped(targetContainer, typeof(TObject), typeof(TService), memberBinding: memberBinding);
}
/// <summary>
/// Creates a <see cref="ConstructorTarget"/> for the given constructor, or a <see cref="GenericConstructorTarget"/> if the
/// constructor belongs to a generic type definition ('open generic type').
/// </summary>
/// <param name="constructor">Required. The constructor to be bound by the target.</param>
/// <param name="memberBinding">Optional - provides an explicit member injection behaviour to be used when creating the instance,
/// if different from the behaviour configured via options on any target container in which the target is subsequently registered.</param>
public static ITarget ForConstructor(
ConstructorInfo constructor,
IMemberBindingBehaviour memberBinding = null)
{
return(ForConstructor(constructor, (ParameterBinding[])null, memberBinding));
}
internal static void RegisterScopedInternal(ITargetContainer targetContainer, Type objectType, Type serviceType, IMemberBindingBehaviour memberBinding)
{
targetContainer.Register(Target.ForType(objectType, memberBinding).Scoped(), serviceType: serviceType);
}
/// <summary>
/// Initializes a just-in-time-bound instance of the <see cref="ConstructorTarget" /> class which must be bound
/// to the best constructor at compile-time by calling the <see cref="Bind(ICompileContext)"/> method.
/// </summary>
/// <param name="type">Required. The type whose constructor is to bound.</param>
/// <param name="namedArgs">Optional. The named arguments which will be passed to, and used to find, the best-matched constructor.
/// These are taken into account when the constructor is sought - with the constructor containing the most matched parameters matched being selected.</param>
/// <param name="memberBinding">Optional - provides an explicit member injection behaviour to be used when creating the instance.
/// If not provided, then the <see cref="Bind(ICompileContext)"/> method will attempt to obtain one via the options API from the
/// <see cref="ICompileContext"/> - and if one is still not available, then no member binding will be performed.</param>
/// <remarks>To compile this target, a <see cref="Compilation.ITargetCompiler"/> first calls the <see cref="Bind(ICompileContext)"/> method
/// to discover the constructor to be executed, along with the final set of arguments to be provided to it (see <see cref="ConstructorBinding"/>).
///
/// The best available constructor is defined as the constructor with the most parameters for which arguments can be resolved from the
/// <see cref="ICompileContext" /> at compile-time to the fewest number of <see cref="ITarget" /> objects whose <see cref="ITarget.UseFallback" />
/// is false.
///
/// *An extension point will be provided in the future which will allow the constructor resolution process to be overriden*
/// </remarks>
public ConstructorTarget(Type type, IDictionary <string, ITarget> namedArgs = null, IMemberBindingBehaviour memberBinding = null)
: this(type, null, memberBinding, null, namedArgs)
{
// it's a post-check, but the private constructor sidesteps null types and ctors to allow the
// public constructors to do their thing.
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
}
