/// <summary>
/// Overridden so that TypeIDPair can be used as the key in dictionaries.
/// </summary>
public override bool Equals(object obj)
{
DependencyResolutionLocatorKey other = obj as DependencyResolutionLocatorKey;
if (other == null)
{
return(false);
}
return(Equals(type, other.type) && Equals(id, other.id));
}
/// <summary>
/// Implementation of <see cref="IBuilderStrategy.BuildUp"/>.
/// </summary>
/// <param name="context">The build context.</param>
/// <param name="typeToBuild">The type of the object being built.</param>
/// <param name="existing">The existing instance of the object.</param>
/// <param name="idToBuild">The ID of the object being built.</param>
/// <returns>The built object.</returns>
public override object BuildUp(IBuilderContext context, Type typeToBuild, object existing, string idToBuild)
{
DependencyResolutionLocatorKey key = new DependencyResolutionLocatorKey(typeToBuild, idToBuild);
if (context.Locator != null && context.Locator.Contains(key, SearchMode.Local))
{
TraceBuildUp(context, typeToBuild, idToBuild, "");
return(context.Locator.Get(key));
}
return(base.BuildUp(context, typeToBuild, existing, idToBuild));
}
/// <summary>
/// Implementation of <see cref="IBuilderStrategy.BuildUp"/>.
/// </summary>
public override object BuildUp(IBuilderContext context, Type t, object existing, string id)
{
DependencyResolutionLocatorKey result = new DependencyResolutionLocatorKey(t, id);
ITypeMappingPolicy policy = context.Policies.Get <ITypeMappingPolicy>(t, id);
if (policy != null)
{
result = policy.Map(result);
TraceBuildUp(context, t, id, Properties.Resources.TypeMapped, result.Type, result.ID ?? "(null)");
Guard.TypeIsAssignableFromType(t, result.Type, t);
}
return(base.BuildUp(context, result.Type, existing, result.ID));
}
/// <summary>
/// Resolves a dependency.
/// </summary>
/// <param name="typeToResolve">The type to be resolved.</param>
/// <param name="typeToCreate">The type to be created, if the type cannot be resolved
/// (and notPresent is set to <see cref="NotPresentBehavior.CreateNew"/>).</param>
/// <param name="id">The ID of the object to be resolved. Pass null for the unnamed object.</param>
/// <param name="notPresent">Flag to describe how to behave if the dependency is not found.</param>
/// <param name="searchMode">Flag to describe whether searches are local only, or local and up.</param>
/// <returns>The dependent object. If the object is not found, and notPresent
/// is set to <see cref="NotPresentBehavior.ReturnNull"/>, will return null.</returns>
public object Resolve(Type typeToResolve, Type typeToCreate, string id, NotPresentBehavior notPresent, SearchMode searchMode)
{
if (typeToResolve == null)
{
throw new ArgumentNullException("typeToResolve");
}
if (!Enum.IsDefined(typeof(NotPresentBehavior), notPresent))
{
throw new ArgumentException(Properties.Resources.InvalidEnumerationValue, "notPresent");
}
if (typeToCreate == null)
{
typeToCreate = typeToResolve;
}
DependencyResolutionLocatorKey key = new DependencyResolutionLocatorKey(typeToResolve, id);
if (context.Locator.Contains(key, searchMode))
{
return(context.Locator.Get(key, searchMode));
}
switch (notPresent)
{
case NotPresentBehavior.CreateNew:
return(context.HeadOfChain.BuildUp(context, typeToCreate, null, key.ID));
case NotPresentBehavior.ReturnNull:
return(null);
default:
throw new DependencyMissingException(
string.Format(CultureInfo.CurrentCulture,
Properties.Resources.DependencyMissing, typeToResolve.ToString()));
}
}
/// <summary>
/// See <see cref="ITypeMappingPolicy.Map"/> for more information.
/// </summary>
public DependencyResolutionLocatorKey Map(DependencyResolutionLocatorKey incomingTypeIDPair)
{
return(pair);
}
/// <summary>
/// Initializes a new instance of the <see cref="TypeMappingPolicy"/> class using
/// the provided type and ID.
/// </summary>
/// <param name="type">The new type to be returned during Map.</param>
/// <param name="id">The new ID to be returned during Map.</param>
public TypeMappingPolicy(Type type, string id)
{
pair = new DependencyResolutionLocatorKey(type, id);
}
