public MethodInfo Find(string methodName, Type targetType, object[] args) { var builder = new PredicateBuilder(); builder.MethodName = methodName; builder.MatchParameters = true; builder.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; Predicate<MethodInfo> finderPredicate = builder.CreatePredicate(); var finder = new FuzzyFinder<MethodInfo>(); finder.Tolerance = .66; // Search for any previous matches MethodInfo bestMatch = finder.Find(finderPredicate, _cachedResults); if (bestMatch == null) { // If there isn't a match, search the current type // for an existing match IEnumerable<MethodInfo> methods = GetMethods(targetType); bestMatch = finder.Find(finderPredicate, methods); } return bestMatch; }
public void MethodMissing(object source, MethodMissingParameters missingParameters) { var builder = new PredicateBuilder(); // The current method name must match the given method name if (_methodName != missingParameters.MethodName) return; if (missingParameters.Arguments != null) builder.RuntimeArguments.AddRange(missingParameters.Arguments); builder.MatchRuntimeArguments = true; Predicate<MethodInfo> finderPredicate = builder.CreatePredicate(); var finder = new FuzzyFinder<MethodInfo>(); finder.Tolerance = .66; // Match the criteria against the target delegate var searchList = new List<MethodInfo>(new[] {_target.Method}); // Determine if the signature is compatible MethodInfo match = finder.Find(finderPredicate, searchList); if (match == null) return; // If the signature is compatible, then execute the method MethodInfo 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 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 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); }