|
public AddPredicates ( IList |
||
| methods | IList |
|
| return | void | |
public MethodInfo Find(string methodName, Type targetType, object[] args)
{
var builder = new PredicateBuilder
{
MethodName = methodName,
MatchParameters = true,
MatchCovariantParameterTypes = true
};
// Find the method that has a compatible signature
// and a matching method name
var arguments = new List <object>();
if (args != null && args.Length > 0)
{
arguments.AddRange(args);
}
builder.RuntimeArguments.AddRange(arguments);
builder.MatchRuntimeArguments = true;
var cachedSearchList = _cachedResults.AsFuzzyList();
builder.AddPredicates(cachedSearchList);
// Search for any previous matches
const double tolerance = .66;
var bestMatch = cachedSearchList.BestMatch(tolerance);
MethodInfo result = null;
if (bestMatch == null)
{
// If there isn't a match, search the current type
// for an existing match
var methods = GetMethods(targetType);
var methodSearchPool = methods.AsFuzzyList();
builder.AddPredicates(methodSearchPool);
bestMatch = methodSearchPool.BestMatch();
}
if (bestMatch != null)
{
result = bestMatch.Item;
}
return(result);
}
public static bool HasCompatibleSignature(this MethodInfo method, MethodInfo targetMethod)
{
var items = new[] { targetMethod };
var searchPool = items.AsFuzzyList();
PredicateBuilder.AddPredicates(searchPool, method);
var match = searchPool.BestMatch(.66);
return(match != null);
}
public MethodInfo Find(string methodName, Type targetType, object[] args)
{
var builder = new PredicateBuilder
{
MethodName = methodName,
MatchParameters = true,
MatchCovariantParameterTypes = true
};
// Find the method that has a compatible signature
// and a matching method name
var arguments = new List<object>();
if (args != null && args.Length > 0)
arguments.AddRange(args);
builder.RuntimeArguments.AddRange(arguments);
builder.MatchRuntimeArguments = true;
var cachedSearchList = _cachedResults.AsFuzzyList();
builder.AddPredicates(cachedSearchList);
// Search for any previous matches
const double tolerance = .66;
var bestMatch = cachedSearchList.BestMatch(tolerance);
MethodInfo result = null;
if (bestMatch == null)
{
// If there isn't a match, search the current type
// for an existing match
var methods = GetMethods(targetType);
var methodSearchPool = methods.AsFuzzyList();
builder.AddPredicates(methodSearchPool);
bestMatch = methodSearchPool.BestMatch();
}
if (bestMatch != null)
result = bestMatch.Item;
return result;
}
public bool LooksLike(Type comparisonType)
{
if (_target == null)
{
return(false);
}
var targetType = _target.GetType();
// Build the list of methods to compare against
var methodPool = new List <MethodInfo>();
// Add the methods native to the type
methodPool.AddRange(targetType.GetMethods(BindingFlags.Public | BindingFlags.Instance));
var searchPool = methodPool.AsFuzzyList();
var comparisonTypeMethods = comparisonType.GetMethods(BindingFlags.Public | BindingFlags.Instance);
var result = true;
foreach (var method in comparisonTypeMethods)
{
// Search for a similar method
searchPool.Reset();
PredicateBuilder.AddPredicates(searchPool, method);
var bestMatch = searchPool.BestMatch(.66);
if (bestMatch == null)
{
continue;
}
var compatibleMethod = bestMatch.Item;
if (compatibleMethod != null)
{
continue;
}
var canHandleMethod = _handlers.Any(callback => callback.CanHandle(method));
// If the search fails, we need to query for a replacement
if (canHandleMethod)
{
continue;
}
result = false;
break;
}
return(result);
}
public void MethodMissing(object source,
MethodMissingParameters missingParameters)
{
// The current method name must match the given method name
if (_methodName != missingParameters.MethodName)
{
return;
}
var builder = new PredicateBuilder();
if (missingParameters.Arguments != null)
{
builder.RuntimeArguments.AddRange(missingParameters.Arguments);
}
builder.MatchRuntimeArguments = true;
// Match the criteria against the target delegate
var items = new List <MethodInfo>(new[] { _target.Method });
var searchItems = items.AsFuzzyList();
// Determine if the signature is compatible
builder.AddPredicates(searchItems);
var match = searchItems.BestMatch();
if (match == null)
{
return;
}
// If the signature is compatible, then execute the method
var targetMethod = _target.Method;
object result = null;
try
{
result = targetMethod.Invoke(_target.Target, missingParameters.Arguments);
missingParameters.Handled = true;
}
catch (TargetInvocationException ex)
{
missingParameters.Handled = false;
throw ex.InnerException;
}
missingParameters.ReturnValue = result;
}
public bool CanHandle(MethodInfo method)
{
var targetType = _target.GetType();
var searchPool =
targetType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
var searchList = searchPool.AsFuzzyList();
PredicateBuilder.AddPredicates(searchList, method);
// Find a method that can handle this particular method signature
var match = searchList.BestMatch(.66);
if (match != null)
{
return(true);
}
return(_handlers.Any(callback => callback.CanHandle(method)));
}
public static void AddPredicates(IList<IFuzzyItem<MethodInfo>> list, MethodInfo method)
{
var builder = new PredicateBuilder { MatchParameters = true, MethodName = method.Name, MatchRuntimeArguments = true };
foreach (var param in method.GetParameters())
{
builder.ParameterTypes.Add(param);
}
// Match any type arguments
if (method.IsGenericMethod)
{
foreach (var current in method.GetGenericArguments())
{
builder.TypeArguments.Add(current);
}
}
builder.ReturnType = method.ReturnType;
builder.AddPredicates(list);
}
public static void AddPredicates(IList <IFuzzyItem <MethodInfo> > list, MethodInfo method)
{
var builder = new PredicateBuilder {
MatchParameters = true, MethodName = method.Name, MatchRuntimeArguments = true
};
foreach (var param in method.GetParameters())
{
builder.ParameterTypes.Add(param);
}
// Match any type arguments
if (method.IsGenericMethod)
{
foreach (var current in method.GetGenericArguments())
{
builder.TypeArguments.Add(current);
}
}
builder.ReturnType = method.ReturnType;
builder.AddPredicates(list);
}
