/// <summary>
/// Gets the mapped method.
/// </summary>
/// <param name="typeOfTheSubject">The type of the subject.</typeparam>
/// <param name="name">The method name.</param>
/// <param name="argTypes">The arguments passed in to the method.</param>
/// <param name="genericArgs">The generic argument types.</param>
/// <returns>
/// The mapped method
/// </returns>
public MappedMethod GetMappedMethod(Type typeOfTheSubject, string name, Type[] argTypes, params Type[] genericArgs)
{
argTypes = argTypes ?? Type.EmptyTypes;
genericArgs = genericArgs ?? Type.EmptyTypes;
Contract.Assume(!string.IsNullOrEmpty(name));
IMethodMapping mapping = this.Lookup(name, argTypes, genericArgs);
if (mapping == default(IMethodMapping))
{
Fasterflect.MethodInvoker invoker = typeOfTheSubject.GetMethod(name, argTypes, genericArgs);
// TODO: Abstract IMethodMapping creation?
mapping = new MethodMapping()
{
Name = name,
ArgumentTypes = argTypes,
GenericArgumentTypes = genericArgs ?? Type.EmptyTypes,
Subject = (subject, args) => invoker(subject, args)
};
this.Add(mapping);
}
MappedMethod method = (args) =>
{
return(mapping.Subject(this.Subject, args));
};
return(method);
}
/// <summary>
/// Adds the specified mapping.
/// </summary>
/// <param name="mapping">The mapping.</param>
/// <param name="replace">if set to <c>true</c> [replaces an IMethodMapping instance, if there is one that matches the signature].</param>
public void Add(IMethodMapping mapping, bool replace = false)
{
Contract.Ensures(this.Contains(mapping));
if (replace)
{
this.Remove(mapping);
}
this.mappings.Add(mapping);
}
/// <summary>
/// Removes the specified mapping.
/// </summary>
/// <param name="mapping">The mapping.</param>
/// <returns>
/// true if removed succesfully, false if it wasn't contained in this IInterfaceMap
/// </returns>
public bool Remove(IMethodMapping mapping)
{
Contract.Ensures(!this.Contains(mapping));
IMethodMapping old = this.Lookup(mapping.Name, mapping.ArgumentTypes.ToArray(), mapping.GenericArgumentTypes.ToArray());
if (old != default(IMethodMapping))
{
return(this.mappings.Remove(old));
}
return(false);
}
public void CanRemoveNonContained()
{
// Arrange
IInterfaceMap target = CreateIInterfaceMap();
IMethodMapping mapping = CreateIMethodMapping();
mapping.Name = "test";
mapping.GenericArgumentTypes = Type.EmptyTypes;
mapping.ArgumentTypes = Type.EmptyTypes;
bool actual;
// Act
actual = target.Remove(mapping);
// Assert
Verify.That(actual).IsFalse()
.Now();
}
public void CanAddWithReplaceSetToFalse()
{
// Arrange
IInterfaceMap target = CreateIInterfaceMap();
IMethodMapping mapping = CreateIMethodMapping();
mapping.Name = "test";
mapping.GenericArgumentTypes = new Type[] { typeof(string), typeof(object) };
mapping.ArgumentTypes = new Type[] { typeof(bool) };
mapping.Subject = (arg, args) =>
{
Console.Out.WriteLine("Subject called");
return(true);
};
bool replace = false;
// Act
target.Add(mapping, replace);
// Assert
Verify.That(target.AsEnumerable()).DoesContain(mapping)
.Now();
}
public void CanReplaceAMethodMapping()
{
// Arrange
IInterfaceMap target = CreateIInterfaceMap();
IMethodMapping mapping = CreateIMethodMapping();
mapping.Name = "test";
mapping.GenericArgumentTypes = new Type[] { typeof(string), typeof(object) };
mapping.ArgumentTypes = new Type[] { typeof(bool) };
mapping.Subject = (arg, args) =>
{
Console.Out.WriteLine("Subject called");
return(true);
};
IMethodMapping replacement = CreateIMethodMapping();
replacement.Name = "test";
replacement.GenericArgumentTypes = new Type[] { typeof(string), typeof(object) };
replacement.ArgumentTypes = new Type[] { typeof(bool) };
replacement.Subject = (arg, args) =>
{
Console.Out.WriteLine("Subject replacement called");
return(true);
};
// Act
target.Add(mapping, false);
target.Add(replacement, true);
// Assert
Verify.That(target.AsEnumerable()).DoesContain(replacement, "Should contain the replacement")
.Now();
Verify.That(target.AsEnumerable()).DoesNotContain(mapping, "Should not contain the original mapping")
.Now();
}
public bool Remove(IMethodMapping mapping)
{
Contract.Requires(mapping != null, "mapping is null.");
return(default(bool));
}
public void Add(IMethodMapping mapping, bool replace = false)
{
Contract.Requires(mapping != null, "mapping is null.");
}
