private static async ValueTask <TResult> ExecuteAsync <TSource, TResult>(System.Reflection.MethodInfo method, IQueryable <TSource> source, IEnumerable <object?> args, CancellationToken cancellation)
{
source.AssertNotNull(nameof(source));
if (method.IsGenericMethodDefinition)
{
var genericArgumentCount = method.GetGenericArguments().Length;
if (genericArgumentCount > 2)
{
throw new RemoteLinqException("Implementation error: expected closed generic method definition.");
}
method = genericArgumentCount == 2
? method.MakeGenericMethod(typeof(TSource), typeof(TResult))
: method.MakeGenericMethod(typeof(TSource));
}
var arguments = new[] { source.Expression }
.Concat(args.Select(x => x is Expression exp ? (Expression)Expression.Quote(exp) : Expression.Constant(x)))
.ToArray();
var methodCallExpression = Expression.Call(method, arguments);
if (source.Provider is IAsyncRemoteQueryProvider asyncQueryableProvider)
{
return(await asyncQueryableProvider.ExecuteAsync <TResult>(methodCallExpression, cancellation).ConfigureAwait(false));
}
return(source.Provider.Execute <TResult>(methodCallExpression));
}
} // End Function MapJTokenTypeToDotNet
private static object GetValue(Newtonsoft.Json.Linq.JToken value, System.Type t)
{
// string foo1 = value.ToString();
// string foo = value.ToObject<string>();
// int bar = value.ToObject<int>();
// System.Reflection.MethodInfo method = GetToObjectMethod();
System.Reflection.MethodInfo generic = s_ToObjectMethodInfo.MakeGenericMethod(t);
return(generic.Invoke(value, null));
} // End Function GetValue
public TestCase(System.Reflection.MethodInfo methodInfo, object[] args) : base(MethodHelper.GetDisplayName(methodInfo, args))
{
this.methodInfo = methodInfo.IsGenericMethod ?
methodInfo.MakeGenericMethod(args.Select(arg => arg.GetType()).ToArray()) :
methodInfo;
this.arguments = args;
}
public static T ToEarlyBoundEntity <T>(this T ent) where T : Microsoft.Xrm.Sdk.Entity
{
if (ent.GetType().BaseType == typeof(Microsoft.Xrm.Sdk.Entity))
{
return(ent);
}
if (TO_ENT_GENS.ContainsKey(ent.LogicalName))
{
return(TO_ENT_GENS[ent.LogicalName].Invoke(ent, new object[0]) as T);
}
if (!entittypes.ContainsKey(ent.LogicalName))
{
var enttype = Reflection.Types.Instance.EntityTypeFor(ent.LogicalName);
if (enttype != null)
{
entittypes[ent.LogicalName] = enttype;
return(ToEarlyBoundEntity(ent));
}
throw new Exceptions.UnknownEntityTypeException(ent.LogicalName);
}
var type = entittypes[ent.LogicalName];
TO_ENT_GENS[ent.LogicalName] = TO_ENTITY.MakeGenericMethod(type);
return(TO_ENT_GENS[ent.LogicalName].Invoke(ent, new object[0]) as T);
}
private WSDynamicEntity ReadSession(/*WSDataContext ZoneContext*/)
{
WSDynamicEntity entity = null;
if (Meta != null && !string.IsNullOrEmpty(SessionID) && ZoneContext != null)
{
long init_ticks = DateTime.Now.Ticks;
try
{
status.AddNote("Zone:" + Meta.Zone, WSConstants.ACCESS_LEVEL.READ);
System.Reflection.MethodInfo mInfo = ZoneContext.GetType().GetMethod("GetTable", new Type[] { });
var tObj = mInfo.MakeGenericMethod(new Type[] { Meta.SessionType }).Invoke(ZoneContext, new object[] { });
Func <WSDynamicEntity, bool> func = s => s.readPropertyValue(WSConstants.PARAMS.SESSIONID.NAME, "").ToString().ToLower().Equals(SessionID.ToLower());
System.Reflection.MethodInfo[] methods = typeof(Enumerable).GetMethods(System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public);
var method = methods.FirstOrDefault(m => m.Name == "FirstOrDefault" && m.GetParameters().Count() == 2).MakeGenericMethod(typeof(WSDynamicEntity));
entity = (WSDynamicEntity)method.Invoke(null, new object[] { tObj, func });
}
catch (Exception e) { CFunc.RegError(GetType(), e, ref status); }
//if (ZoneContext != null) ZoneContext.Close(/*SessionID*/);
TimeSpan ticks1 = new TimeSpan(DateTime.Now.Ticks - init_ticks); init_ticks = DateTime.Now.Ticks;
}
return(entity);
}
private TResult MapAsyncEnumerable <TResult>(Type elementType, IAsyncEnumerable <TSource?> source, CancellationToken cancellation)
{
var method = _mapAsyncEnumerableMethodInfo.MakeGenericMethod(elementType);
var result = method.Invoke(null, new object[] { source, _resultMapper, cancellation });
return((TResult)result !);
}
protected override void EndProcessing()
{
base.EndProcessing();
if (Width <= 0)
{
PSHost host = GetVariableValue("Host") as PSHost;
Width = host.UI.RawUI.WindowSize.Width;
}
Height = System.Math.Max(1, Height);
Width = System.Math.Max(1, Width);
ColorSpace = ColorSpace.Substring(0, 1).ToUpperInvariant() + ColorSpace.Substring(1).ToLowerInvariant();
var colorType = GetType().Assembly.GetType($"PoshCode.Pansies.ColorSpaces.{ColorSpace}");
var colors = (RgbColor[][])Get2DGradient.MakeGenericMethod(typeof(RgbColor), colorType).Invoke(null,
new object[] { StartColor, EndColor, Height, Width, Reverse.ToBool() });
if (Flatten || Height == 1)
{
foreach (var row in colors)
{
foreach (var col in row)
{
WriteObject(col);
}
}
}
else
{
WriteObject(colors, false);
}
}
public IMethod GetMethodT(string funcname, MethodParamList ttypes, MethodParamList types)
{
//这个实现还不完全
//有个别重构下，判定比这个要复杂
System.Reflection.MethodInfo _method = null;
var ms = TypeForSystem.GetMethods();
foreach (var m in ms)
{
if (m.Name == funcname && m.IsGenericMethodDefinition)
{
var ts = m.GetGenericArguments();
var ps = m.GetParameters();
if (ts.Length == ttypes.Count && ps.Length == types.Count)
{
_method = m;
break;
}
}
}
// _method = TypeForSystem.GetMethod(funcname, types.ToArraySystem());
return(new Method_Common_System(this, _method.MakeGenericMethod(ttypes.ToArraySystem())));
}
/// <summary>
/// Thread which listens for incoming NetMQMessages from the server and queues them up for handling
/// </summary>
private void Listener()
{
while (!isDone)
{
NetMQMessage message = null;
if (clientSocket.TryReceiveMultipartMessage(TimeSpan.FromSeconds(1.0), ref message))
{
string typeStr = message[1].ConvertToString();
Type objectType = Type.GetType(typeStr);
System.Reflection.MethodInfo method = typeof(BsonMagic).GetMethod("DeserializeObject");
System.Reflection.MethodInfo generic = method.MakeGenericMethod(objectType);
Object[] methodParams = new Object[1] {
message[2].ToByteArray()
};
Object receivedObject = generic.Invoke(null, methodParams);
if (DataReceived != null)
{
DataReceived(receivedObject);
}
else
{
throw new ArgumentException("Data was received, but no event handler set!");
}
}
}
}
private async Task RemoveProcessedEvent(CqrsEventProcessedEvent request, System.Reflection.MethodInfo getRepositoryMethod, CancellationToken cancellationToken)
{
_logger.Debug($"Getting destination entity repository. DestinationTypeName: {request.DestinationTypeName}");
var destinationEntityType = Type.GetType(request.DestinationTypeName);
var genericMethodForDestinationEntity = getRepositoryMethod.MakeGenericMethod(destinationEntityType);
dynamic destinationEntityRepository = genericMethodForDestinationEntity.Invoke(_cqrsRepositoryFactory, null);
_logger.Debug($"Built {nameof(CqrsRepositoryFactory)}");
using var uow = _unitOfWorkManager.Get();
_logger.Debug($"Fetched destination entity by Id. Id: {request.DestinationId}");
var cqrsEntity = await destinationEntityRepository.GetByIdAsync(request.DestinationId, cancellationToken);
var baseCqrsEntity = cqrsEntity as BaseCqrsEntity;
_logger.Debug($"Fetched BaseCqrsEntity. Id: {request.DestinationId}");
var @event = baseCqrsEntity?.ProcessedEvents.FirstOrDefault(f => f.Id == request.Id);
if (@event != null)
{
_logger.Debug($"Removing event. Id: {@event.Id}");
baseCqrsEntity.RemoveProcessedEvent(@event);
await destinationEntityRepository.UpdateAsync(cqrsEntity, cancellationToken);
_logger.Debug($"Removed event");
}
uow.Commit();
}
internal static MessagePackSerializer CreateInternal(SerializationContext context, Type targetType, PolymorphismSchema schema)
{
#if UNITY
return
((
Delegate.CreateDelegate(
typeof(Func <SerializationContext, PolymorphismSchema, object>),
CreateInternal_2.MakeGenericMethod(targetType)
)
as Func <SerializationContext, PolymorphismSchema, object>)(context, schema) as MessagePackSerializer);
#else
return
((CreateInternal_2.MakeGenericMethod(targetType).CreateDelegate(typeof(Func <SerializationContext, PolymorphismSchema, object>))
as Func <SerializationContext, PolymorphismSchema, object>)(context, schema) as MessagePackSerializer);
#endif // UNITY
}
/// <summary>
/// Get MethodInfo to Invoke through Reflection
/// </summary>
/// <param name="entityType"></param>
/// <param name="methodName"></param>
/// <param name="columnType"></param>
/// <returns></returns>
protected static System.Reflection.MethodInfo GetMethodInfo(System.Type entityType, System.String methodName, System.Type columnType)
{
System.Reflection.MethodInfo[] methods = entityType.GetMethods();
System.Reflection.MethodInfo method = methods.Where(m => m.Name == methodName && m.IsGenericMethod).FirstOrDefault();
return(method.MakeGenericMethod(new System.Type[] { columnType }));
}
public void DeserializeCollection(string serializedItems)
{
string[] items = serializedItems.Split('|');
for (int i = 0; i < items.Length; i++)
{
string[] keyItem = items[i].Split('=');
if (keyItem.Length < 1)
{
throw new SerializationException("Unexpected serialization data format.");
}
string colKey = keyItem[0];
string itemData = System.Text.Encoding.UTF8.GetString(Hex.GetBytes(keyItem[1]));
Type tType = typeof(T);
System.Reflection.MethodInfo getFromSerializedMethod = tType.GetMethod("FromSerializedData"
, System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.FlattenHierarchy
, null
, new Type[] { typeof(System.String) }
, null);
if (getFromSerializedMethod == null)
{
throw new Exception("Unable to determine method to get new item from serialized data.");
}
// This takes the method we found a few lines up, and constructs a generic call with the "T"
// data type attached. This is the MethodInfo we'll actually invoke to call the method.
System.Reflection.MethodInfo genericMethodCall = getFromSerializedMethod.MakeGenericMethod(tType);
// This should call this same method for the Type of the specified property.
T qa = (T)genericMethodCall.Invoke(null, new object[] { itemData });
this.Add(qa, colKey);
}
}
private ValueTask <TResult> MapSingleElementStream <TResult>(IAsyncEnumerable <TSource?> source, CancellationToken cancellation)
{
var method = _mapSingleElementStreamMethodInfo.MakeGenericMethod(typeof(TResult));
var result = method.Invoke(null, new object[] { source, _resultMapper, cancellation });
return((ValueTask <TResult>)result !);
}
internal static IMessagePackSingleObjectSerializer CreateReflectionInternal(SerializationContext context, Type targetType)
{
#if UNITY_ANDROID || UNITY
return
((
Delegate.CreateDelegate(
typeof(Func <SerializationContext, object>),
CreateReflectionInternal_1.MakeGenericMethod(targetType)
)
as Func <SerializationContext, object>)(context) as IMessagePackSingleObjectSerializer);
#else
return
((CreateReflectionInternal_1.MakeGenericMethod(targetType).CreateDelegate(typeof(Func <SerializationContext, object>))
as Func <SerializationContext, object>)(context) as IMessagePackSingleObjectSerializer);
#endif
}
public sealed override void ReceivedSettings(ReceivedSettingsPayload payload)
{
var genAutoPopInfo = AutoPopInfo.MakeGenericMethod(settings.GetType());
genAutoPopInfo.Invoke(null, new object[] { settings, payload.Settings });
ApplySettings();
Connection.SetSettingsAsync(JObject.FromObject(settings));
}
/// <summary>
/// Cria a expressão de acesso ao membro.
/// </summary>
/// <returns></returns>
public override System.Linq.Expressions.Expression CreateMemberAccessExpression()
{
var expression = System.Linq.Expressions.Expression.Constant(base.MemberName);
return(System.Linq.Expressions.Expression.Call(DataRowFieldMethod.MakeGenericMethod(new Type[] {
this.columnDataType
}), base.ParameterExpression, expression));
}
public static string GetDisplayName(System.Reflection.MethodInfo method, object[] arglist)
{
if (method.IsGenericMethod)
{
method = method.MakeGenericMethod(GetArgumentTypes(arglist));
}
return(GetDisplayName(method, method.Name, arglist));
}
/// <summary>
/// Cria a expressão de acesso ao membro.
/// </summary>
/// <returns></returns>
public override System.Linq.Expressions.Expression CreateMemberAccessExpression()
{
var expression = System.Linq.Expressions.Expression.Constant(base.MemberName);
return(System.Linq.Expressions.Expression.Call(PropertyMethod.MakeGenericMethod(new Type[] {
this._propertyType
}), base.ParameterExpression, expression));
}
/// <summary>
/// Gets the generic method for a given type (caches internally for speedup).
/// </summary>
/// <param name="classContainingMethod">The class containing the method.</param>
/// <param name="methodName">Name of the method.</param>
/// <param name="genericType">Type to find a generic method for.</param>
/// <param name="paramTypes">The parameter types to resolve possible ambiguity (if necessary, may be null).</param>
/// <returns></returns>
public static System.Reflection.MethodInfo GetGenericMethod(Type classContainingMethod, string methodName, Type genericType, Type[] paramTypes)
{
// NOTE: See also this discussion about an maybe easier way:
// How do I use reflection to call a generic method?
// http://stackoverflow.com/a/232621
if (string.IsNullOrWhiteSpace(methodName) || null == genericType)
{
return(null);
}
string key = classContainingMethod.ToString() + "#" + methodName + "#" + genericType.ToString();
if (null != paramTypes)
{
foreach (Type t in paramTypes)
{
key += "#" + t.ToString();
}
}
if (_GenericMethodsCache.ContainsKey(key))
{
// Cache hit
return(_GenericMethodsCache[key]);
}
// Using System.Type to call a generic method
// http://stackoverflow.com/a/14222568
//System.Reflection.MethodInfo method = this.GetType().GetMethods()
// .First(m => m.Name == "QuerySingle" && m.GetParameters().Any(par => par.ParameterType == typeof(IDictionary<string, object>)));
System.Reflection.MethodInfo method = null;
if (null != paramTypes)
{
method = classContainingMethod.GetMethod(methodName, paramTypes);
}
else
{
method = classContainingMethod.GetMethod(methodName);
}
if (null == method)
{
return(null);
}
System.Reflection.MethodInfo genericMethod = method.MakeGenericMethod(genericType);
if (null == genericMethod)
{
return(null);
}
// Cache found generic method
_GenericMethodsCache[key] = genericMethod;
return(genericMethod);
}
/// <summary>
/// Generate default variables to an option
/// </summary>
/// <param name="options"></param>
public static void GenerateDefaultVariables(ITypeOptions options)
{
foreach (KeyValuePair <Type, string> variableType in ReflectionHelper.VariableTypes)
{
System.Reflection.MethodInfo method = typeof(BaseTypeGoInfo).GetMethods(System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic)
.FirstOrDefault(x => x.Name == "Generate" && x.GetGenericArguments().Length == 1);
System.Reflection.MethodInfo genericMethod = method.MakeGenericMethod(variableType.Key);
genericMethod.Invoke(null, new object[] { options });
}
}
private static IOrderedQueryable<T> Sort<T>(this IQueryable<T> queryable, SystemLinq.LambdaExpression lambdaExpression, MethodInfo methodInfo)
{
queryable.AssertNotNull(nameof(queryable));
var exp = lambdaExpression.CheckNotNull(nameof(lambdaExpression)).Body;
var resultType = exp.Type;
var funcType = typeof(Func<,>).MakeGenericType(typeof(T), resultType);
var lambdaExpressionMethodInfo = MethodInfos.Expression.Lambda.MakeGenericMethod(funcType);
var funcExpression = lambdaExpressionMethodInfo.Invoke(null, new object[] { exp, lambdaExpression.Parameters.ToArray() });
var method = methodInfo.MakeGenericMethod(typeof(T), resultType);
var result = method.Invoke(null, new object[] { queryable, funcExpression! });
public static EntitySetConfiguration AddClrObject(this ODataModelBuilder builder, AssemblyTableInfo assemblyTableInfo)
{
System.Reflection.MethodInfo methodEntitySet = builder.GetType().GetMethod("EntitySet");
var genericEntityType = methodEntitySet.MakeGenericMethod(assemblyTableInfo.ClrTypeClass);
//Registers an EntitySet<genericEntityType>(EntitySetName);
var entitySetConfiguration = genericEntityType.Invoke(builder, new object[] { assemblyTableInfo.EntitySetName });
listTablesInfo.Add(assemblyTableInfo);
return(entitySetConfiguration as EntitySetConfiguration);
}
public T CreateUsingNested <T>(string name) where T : VisualElement, new()
{
var t = typeof(T);
var nestedType = NestedTypes.Where(x => x.Name == name && (x.IsSubclassOf(t) || x.IsSubclassOf(t.BaseType))).FirstOrDefault();
if (nestedType != null)
{
return(CreateMethod_INFO.MakeGenericMethod(nestedType).Invoke(m_Base, new object[1] {
name
}) as T);
}
return(m_Base.CreateElement <T>());
}
public AgentEventRectifier(IEnumerable <Type> types, INotifierQueryable agent_instance)
{
this._Types = types.ToArray();
_RemoveHandlers = new List <System.Action>();
Type agentType = typeof(INotifierQueryable);
System.Reflection.MethodInfo agentQueryNotifier = agentType.GetMethod(nameof(INotifierQueryable.QueryNotifier));
foreach (Type type in _Types)
{
if (!type.IsInterface)
{
continue;
}
System.Reflection.MethodInfo agentQueryNotifierT = agentQueryNotifier.MakeGenericMethod(type);
object notifyInstance = agentQueryNotifierT.Invoke(agent_instance, new object[0]);
Type notifyTypeT = typeof(INotifier <>).MakeGenericType(type);
System.Reflection.EventInfo notifySupply = notifyTypeT.GetEvent(nameof(INotifier <object> .Supply));
System.Reflection.EventInfo notifyUnsupply = notifyTypeT.GetEvent(nameof(INotifier <object> .Unsupply));
Utility.Reflection.TypeMethodCatcher catcherSupply = new Regulus.Utility.Reflection.TypeMethodCatcher((System.Linq.Expressions.Expression <Action <AgentEventRectifier> >)(ins => ins._Supply <object>(null)));
System.Reflection.MethodInfo supplyGenericMethod = catcherSupply.Method.GetGenericMethodDefinition();
System.Reflection.MethodInfo supplyMethod = supplyGenericMethod.MakeGenericMethod(type);
Utility.Reflection.TypeMethodCatcher catcherUnsupply = new Regulus.Utility.Reflection.TypeMethodCatcher((System.Linq.Expressions.Expression <Action <AgentEventRectifier> >)(ins => ins._Unsupply <object>(null)));
System.Reflection.MethodInfo unsupplyGenericMethod = catcherUnsupply.Method.GetGenericMethodDefinition();
System.Reflection.MethodInfo unsupplyMethod = unsupplyGenericMethod.MakeGenericMethod(type);
Type actionT1 = typeof(System.Action <>);
Type actionT = actionT1.MakeGenericType(type);
Delegate delegateSupply = Delegate.CreateDelegate(actionT, this, supplyMethod);
Delegate delegateUnsupply = Delegate.CreateDelegate(actionT, this, unsupplyMethod);
notifySupply.AddEventHandler(notifyInstance, delegateSupply);
notifyUnsupply.AddEventHandler(notifyInstance, delegateUnsupply);
_RemoveHandlers.Add(() =>
{
notifySupply.RemoveEventHandler(notifyInstance, delegateSupply);
notifyUnsupply.RemoveEventHandler(notifyInstance, delegateUnsupply);
});
}
}
internal static object GetDefaultValue(Type type)
{
// null is always the default for non value types and Nullable<>
if (!type.IsValueType ||
(type.IsGenericType &&
typeof(Nullable <>) == type.GetGenericTypeDefinition()))
{
return(null);
}
System.Reflection.MethodInfo getDefaultMethod = s_getDefaultMethod.MakeGenericMethod(type);
object defaultValue = getDefaultMethod.Invoke(null, new object[] { });
return(defaultValue);
}
private static IOrderedQueryable <T> Sort <T>(this IQueryable <T> queryable, LambdaExpression lambdaExpression, MethodInfo methodInfo)
{
var exp = lambdaExpression.Body;
var resultType = exp.Type;
var funcType = typeof(Func <,>).MakeGenericType(typeof(T), resultType);
var lambdaExpressionMethodInfo = MethodInfos.Expression.Lambda.MakeGenericMethod(funcType);
var funcExpression = lambdaExpressionMethodInfo.Invoke(null, new object[] { exp, lambdaExpression.Parameters.ToArray() });
var method = methodInfo.MakeGenericMethod(typeof(T), resultType);
var result = method.Invoke(null, new object[] { queryable, funcExpression });
return((IOrderedQueryable <T>)result);
}
private static void AddPrefab(string name, System.Type type)
{
if (PrefabAlreadyExists(name))
{
Fabric.Internal.Editor.Utils.Log("{0} already exists in this scene", name);
return;
}
GameObject gameObject = new GameObject(name);
System.Reflection.MethodInfo addComponent = typeof(GameObject).GetMethod("AddComponent", new System.Type[] {});
System.Reflection.MethodInfo addComponentGeneric = addComponent.MakeGenericMethod(type);
addComponentGeneric.Invoke(gameObject, null);
}
public static T2 ToSigned <T2>(T input)
{
if (IsSigned)
{
return((T2)(object)input);
}
// T is Unsigned
// t is signed type for T
System.Type t = MapUnsignedSigned[typeof(T)];
// TSigned UnsignedToSigned<TUnsigned, TSigned>(TUnsigned ulongValue)
// return UnsignedToSigned<T, t> (input);
System.Reflection.MethodInfo method = typeof(Number <T>).GetMethod("UnsignedToSigned");
System.Reflection.MethodInfo genericMethod = method.MakeGenericMethod(typeof(T), t);
return((T2)genericMethod.Invoke(null, new object[] { input }));
}
/// <summary>
/// Gets the generic method for a given type (caches internally for speedup).
/// <locDE><para />Holt die generische Methode für den angegebenen Typ (cacht intern zur Geschwindigkeitssteigerung).</locDE>
/// </summary>
/// <param name="classContainingMethod">The class containing the method.<locDE><para />Die Klasse, welche die Methode enthält.</locDE></param>
/// <param name="methodName">The name of the method.<locDE><para />Der Methodenname.</locDE></param>
/// <param name="genericType">The type to find a generic method for.<locDE><para />Der Typ, für welchen eine generische Methode gefunden werden soll.</locDE></param>
/// <param name="bindingFlags">The binding flags.<locDE><para />Die Bindungsflags.</locDE></param>
/// <returns>MethodInfo object (if found).<locDE><para />MethodInfo-Objekt (falls gefunden).</locDE></returns>
public static System.Reflection.MethodInfo GetGenericMethod(Type classContainingMethod, string methodName,
System.Reflection.BindingFlags bindingFlags = System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Public,
Type genericType = null)
{
// NOTE: See also this discussion about an maybe easier way:
// How do I use reflection to call a generic method?
// http://stackoverflow.com/a/232621
if (string.IsNullOrWhiteSpace(methodName))
{
return(null);
}
string key = classContainingMethod.ToStringInvariant() + "#" + methodName + "#" + genericType.ToStringInvariant() + "#" + bindingFlags.ToStringInvariant();
if (_GenericMethodsCache.ContainsKey(key))
{
// Cache hit
return(_GenericMethodsCache[key]);
}
// Using System.Type to call a generic method
// http://stackoverflow.com/a/14222568
//System.Reflection.MethodInfo method = this.GetType().GetMethods()
// .First(m => m.Name == "QuerySingle" && m.GetParameters().Any(par => par.ParameterType == typeof(IDictionary<string, object>)));
System.Reflection.MethodInfo method = null;
method = classContainingMethod.GetMethod(methodName, bindingFlags);
if (null == method)
{
return(null);
}
if (null != genericType)
{
System.Reflection.MethodInfo genericMethod = method.MakeGenericMethod(genericType);
if (null == genericMethod)
{
return(null);
}
method = genericMethod;
}
// Cache found generic method
_GenericMethodsCache[key] = method;
return(method);
}