I had similar problems with TinyIoC, and instead of “converting”, the “cleanest” solution I found was to make your method general (so public IEnumerable'T DoStuff'T ()) and then call this using MakeGenericMethod using your runtime type. It stays “clean” because your actual method that creates the list only works as if it were the usual universal method, so it doesn't clutter castings, etc.
Without seeing your code, it's hard to see if this matches the bill - here are the relevant bits to make a general method from TinyIoc:
public static class TypeExtensions { private static SafeDictionary<GenericMethodCacheKey, MethodInfo> _genericMethodCache; static TypeExtensions() { _genericMethodCache = new SafeDictionary<GenericMethodCacheKey, MethodInfo>(); } /// <summary> /// Gets a generic method from a type given the method name, binding flags, generic types and parameter types /// </summary> /// <param name="sourceType">Source type</param> /// <param name="bindingFlags">Binding flags</param> /// <param name="methodName">Name of the method</param> /// <param name="genericTypes">Generic types to use to make the method generic</param> /// <param name="parameterTypes">Method parameters</param> /// <returns>MethodInfo or null if no matches found</returns> /// <exception cref="System.Reflection.AmbiguousMatchException"/> /// <exception cref="System.ArgumentException"/> public static MethodInfo GetGenericMethod(this Type sourceType, System.Reflection.BindingFlags bindingFlags, string methodName, Type[] genericTypes, Type[] parameterTypes) { MethodInfo method; var cacheKey = new GenericMethodCacheKey(sourceType, methodName, genericTypes, parameterTypes); // Shouldn't need any additional locking // we don't care if we do the method info generation // more than once before it gets cached. if (!_genericMethodCache.TryGetValue(cacheKey, out method)) { method = GetMethod(sourceType, bindingFlags, methodName, genericTypes, parameterTypes); _genericMethodCache[cacheKey] = method; } return method; } private static MethodInfo GetMethod(Type sourceType, BindingFlags bindingFlags, string methodName, Type[] genericTypes, Type[] parameterTypes) { var methods = sourceType.GetMethods(bindingFlags).Where( mi => string.Equals(methodName, mi.Name, StringComparison.InvariantCulture)).Where( mi => mi.ContainsGenericParameters).Where(mi => mi.GetGenericArguments().Length == genericTypes.Length). Where(mi => mi.GetParameters().Length == parameterTypes.Length).Select( mi => mi.MakeGenericMethod(genericTypes)).Where( mi => mi.GetParameters().Select(pi => pi.ParameterType).SequenceEqual(parameterTypes)).ToList(); if (methods.Count > 1) { throw new AmbiguousMatchException(); } return methods.FirstOrDefault(); } private sealed class GenericMethodCacheKey { private readonly Type _sourceType; private readonly string _methodName; private readonly Type[] _genericTypes; private readonly Type[] _parameterTypes; private readonly int _hashCode; public GenericMethodCacheKey(Type sourceType, string methodName, Type[] genericTypes, Type[] parameterTypes) { _sourceType = sourceType; _methodName = methodName; _genericTypes = genericTypes; _parameterTypes = parameterTypes; _hashCode = GenerateHashCode(); } public override bool Equals(object obj) { var cacheKey = obj as GenericMethodCacheKey; if (cacheKey == null) return false; if (_sourceType != cacheKey._sourceType) return false; if (!String.Equals(_methodName, cacheKey._methodName, StringComparison.InvariantCulture)) return false; if (_genericTypes.Length != cacheKey._genericTypes.Length) return false; if (_parameterTypes.Length != cacheKey._parameterTypes.Length) return false; for (int i = 0; i < _genericTypes.Length; ++i) { if (_genericTypes[i] != cacheKey._genericTypes[i]) return false; } for (int i = 0; i < _parameterTypes.Length; ++i) { if (_parameterTypes[i] != cacheKey._parameterTypes[i]) return false; } return true; } public override int GetHashCode() { return _hashCode; } private int GenerateHashCode() { unchecked { var result = _sourceType.GetHashCode(); result = (result * 397) ^ _methodName.GetHashCode(); for (int i = 0; i < _genericTypes.Length; ++i) { result = (result * 397) ^ _genericTypes[i].GetHashCode(); } for (int i = 0; i < _parameterTypes.Length; ++i) { result = (result * 397) ^ _parameterTypes[i].GetHashCode(); } return result; } } } }
This is called the following:
private object GetIEnumerableRequest(Type type) { var genericResolveAllMethod = this.GetType().GetGenericMethod(BindingFlags.Public | BindingFlags.Instance, "ResolveAll", type.GetGenericArguments(), new[] { typeof(bool) }); return genericResolveAllMethod.Invoke(this, new object[] { false }); }
And ResolveAll is defined as:
public IEnumerable<ResolveType> ResolveAll<ResolveType>() where ResolveType : class { return ResolveAll<ResolveType>(true); }
Hope this makes sense :)