本文整理汇总了C#中System.Reflection.MethodInfo.MakeGenericMethod方法的典型用法代码示例。如果您正苦于以下问题:C# MethodInfo.MakeGenericMethod方法的具体用法?C# MethodInfo.MakeGenericMethod怎么用?C# MethodInfo.MakeGenericMethod使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类System.Reflection.MethodInfo
的用法示例。
在下文中一共展示了MethodInfo.MakeGenericMethod方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: GetMethodInfo
private static MethodInfo GetMethodInfo(MethodInfo mi, MemberInfo memberInfo)
{
if (memberInfo is FieldInfo) {
return mi.MakeGenericMethod ((memberInfo as FieldInfo).FieldType);
}
if (memberInfo is PropertyInfo) {
return mi.MakeGenericMethod ((memberInfo as PropertyInfo).PropertyType);
}
return null;
}
示例2: InvokeGenericMethod
public object InvokeGenericMethod(MethodInfo genericMethodDefinition, Type[] genericArguments, object instance, object[] arguments)
{
Debug.Assert(genericMethodDefinition.IsGenericMethodDefinition);
var method = genericMethodDefinition.MakeGenericMethod(genericArguments);
return InvokeMethod(method, instance, arguments);
}
示例3: CreateCall
private static Expression CreateCall(MethodInfo method, ParameterExpression handler, ParameterExpression context, Type handlerType)
{
if (method.IsGenericMethod)
{
var handlerParameterType = method.GetParameters()[0].ParameterType;
if (handlerParameterType.IsGenericType)
{
var @interface =
handlerType.GetInterfaces().FirstOrDefault(
i =>
i.IsGenericType &&
i.GetGenericTypeDefinition() == handlerParameterType.GetGenericTypeDefinition());
if (@interface != null)
{
method = method.MakeGenericMethod(@interface.GetGenericArguments().Single());
}
}
else
{
// bind handler as generic type?
method = method.MakeGenericMethod(typeof(object));
//Debugger.Break();
}
}
return Expression.Call(method, handler, context);
}
示例4: Method
public void Method(
MethodInfo mi
, int argToTest)
{
var genericArgsInfo = mi.GetGenericArguments();
int aggregateCount = genericArgsInfo.Count(t => Regex.IsMatch(t.Name, "^TA"));
if (genericArgsInfo.Length > 0)
mi = mi.MakeGenericMethod(genericArgsInfo.Select(
p => p.Name == "TSourceAggregates" ? typeof(Tuple<int, int>) : typeof(int)).ToArray());
var paramInfos = mi.GetParameters();
var callArguments = paramInfos.Select((p, i) =>
{
object arg = null;
if (p.ParameterType.IsValueType)
arg = Activator.CreateInstance(p.ParameterType);
else if (i < argToTest)
arg = ConstructArgument(p.ParameterType, aggregateCount);
return Expression.Constant(arg, p.ParameterType);
});
Action callWithBoundArguments = Expression.Lambda<Action>(Expression.Call(mi, callArguments)).Compile();
Assert.That(new TestDelegate(callWithBoundArguments), Throws.TypeOf(typeof(ArgumentNullException))
.With.Property("ParamName").EqualTo(paramInfos[argToTest].Name));
}
示例5: ArgsMatch
private static bool ArgsMatch(MethodInfo m, ReadOnlyCollection<Expression> args, Type[] typeArgs)
{
ParameterInfo[] parameters = m.GetParameters();
if (parameters.Length != args.Count)
{
return false;
}
if ((!m.IsGenericMethod && (typeArgs != null)) && (typeArgs.Length > 0))
{
return false;
}
if ((!m.IsGenericMethodDefinition && m.IsGenericMethod) && m.ContainsGenericParameters)
{
m = m.GetGenericMethodDefinition();
}
if (m.IsGenericMethodDefinition)
{
if ((typeArgs == null) || (typeArgs.Length == 0))
{
return false;
}
if (m.GetGenericArguments().Length != typeArgs.Length)
{
return false;
}
m = m.MakeGenericMethod(typeArgs);
parameters = m.GetParameters();
}
int index = 0;
int count = args.Count;
while (index < count)
{
Type parameterType = parameters[index].ParameterType;
if (parameterType == null)
{
return false;
}
if (parameterType.IsByRef)
{
parameterType = parameterType.GetElementType();
}
Expression operand = args[index];
if (!parameterType.IsAssignableFrom(operand.Type))
{
if (operand.NodeType == ExpressionType.Quote)
{
operand = ((UnaryExpression) operand).Operand;
}
if (!parameterType.IsAssignableFrom(operand.Type) && !parameterType.IsAssignableFrom(StripExpression(operand.Type)))
{
return false;
}
}
index++;
}
return true;
}
示例6: OptionalTypeConverter
static OptionalTypeConverter()
{
optional = (from info in typeof(Prelude).GetMethods()
where info.Name == "Optional"
select info)
.First();
methods = Prelude.memo((Type valueType) => optional.MakeGenericMethod(valueType));
}
示例7: SomeTypeConverter
static SomeTypeConverter()
{
someCreate = (from info in typeof(Some).GetMethods()
where info.Name == "Create"
select info)
.First();
methods = Prelude.memo((Type valueType) => someCreate.MakeGenericMethod(valueType));
}
示例8: Add
private static void Add(this ConfigurationRegistrar configurationRegistrar,Type modelConfigurationType, Type modelType, MethodInfo addMethod)
{
if (modelType != null)
{
addMethod
.MakeGenericMethod(modelType)
.Invoke(configurationRegistrar, new[] { Activator.CreateInstance(modelConfigurationType) });
}
}
示例9: ShouldMatchGenericParameters
public void ShouldMatchGenericParameters()
{
targetMethod = typeof(MethodFinderTargetDummy).GetMethod("DoSomethingGeneric");
Assert.IsTrue(targetMethod.IsGenericMethodDefinition);
Type typeArgument = typeof(int);
targetMethod = targetMethod.MakeGenericMethod(typeArgument);
builder.TypeArguments.Add(typeArgument);
RunTest();
}
示例10: Case
public Case(MethodInfo caseMethod, params object[] parameters)
{
this.parameters = parameters != null && parameters.Length == 0 ? null : parameters;
Class = caseMethod.ReflectedType;
Method = caseMethod.IsGenericMethodDefinition
? caseMethod.MakeGenericMethod(GenericArgumentResolver.ResolveTypeArguments(caseMethod, parameters))
: caseMethod;
Name = GetName();
}
示例11: MakeClosedGenericExecuteMethod
/// <summary>
/// Takes the given <paramref name="genericMethodDefinition"/> and instantiates it, substituting its generic parameter with the value
/// type of the value held by this object. The method must have exactly one generic parameter.
/// </summary>
/// <param name="genericMethodDefinition">The generic method definition to instantiate.</param>
/// <returns>
/// A closed generic instantiation of <paramref name="genericMethodDefinition"/> with this object's value type substituted for
/// the generic parameter.
/// </returns>
public MethodInfo MakeClosedGenericExecuteMethod (MethodInfo genericMethodDefinition)
{
ArgumentUtility.CheckNotNull ("genericMethodDefinition", genericMethodDefinition);
if (!genericMethodDefinition.IsGenericMethodDefinition)
throw new ArgumentException ("GenericMethodDefinition must be a generic method definition.", "genericMethodDefinition");
if (genericMethodDefinition.GetGenericArguments ().Length != 1)
throw new ArgumentException ("GenericMethodDefinition must have exactly one generic parameter.", "genericMethodDefinition");
return genericMethodDefinition.MakeGenericMethod (DataType);
}
示例12: BindDelegateExpression
public BindDelegateExpression(Type @delegate, Expression owner, MethodInfo methodToBindTo, GenericTypeParameterBuilder[] genericTypeParams)
{
delegateCtor = @delegate.GetConstructors()[0];
this.methodToBindTo = methodToBindTo;
if(@delegate.IsGenericTypeDefinition)
{
var closedDelegate = @delegate.MakeGenericType(genericTypeParams);
delegateCtor = TypeBuilder.GetConstructor(closedDelegate, delegateCtor);
this.methodToBindTo = methodToBindTo.MakeGenericMethod(genericTypeParams);
}
this.owner = owner;
}
示例13: InitializeProxyMethod
public bool InitializeProxyMethod(MethodInfo sourceMethod, Type[] types, out MethodInfo proxyMethod)
{
var proxyType = this.ProxyType;
if (types == null) throw new ArgumentOutOfRangeException("types");
var proxyTypeArgs = new List<Type>();
if (ReflectionHelper.IsGenericType(sourceMethod.DeclaringType))
{
proxyTypeArgs.AddRange(sourceMethod.DeclaringType.GetTypeInfo().GenericTypeArguments);
}
if (sourceMethod.IsGenericMethod)
{
proxyTypeArgs.AddRange(sourceMethod.GetGenericArguments());
}
var typeArrayPointer = 0;
if (proxyType.IsGenericTypeDefinition)
{
var typeArgs = new Type[proxyType.GenericTypeParameters.Length];
for (int i = 0; i < typeArgs.Length; i++)
{
typeArgs[i] = proxyTypeArgs[typeArrayPointer];
typeArrayPointer++;
}
proxyType = proxyType.MakeGenericType(typeArgs).GetTypeInfo();
}
if (proxyTypeArgs.Count == typeArrayPointer)
{
proxyMethod = proxyType.GetDeclaredMethods(MethodName).FirstOrDefault(m => CheckTypes(m.GetParameters(), types));
}
else
{
var typeArgs = new Type[proxyTypeArgs.Count - typeArrayPointer];
for (int i = 0; i < typeArgs.Length; i++)
{
typeArgs[i] = proxyTypeArgs[typeArrayPointer];
typeArrayPointer++;
}
proxyMethod = proxyType.GetDeclaredMethods(MethodName).FirstOrDefault(m =>
{
if (!m.IsGenericMethodDefinition || m.GetGenericArguments().Length != typeArgs.Length) return false;
var genericMethod = m.MakeGenericMethod(typeArgs);
return CheckTypes(genericMethod.GetParameters(), types);
});
if (proxyMethod != null)
{
proxyMethod = proxyMethod.MakeGenericMethod(typeArgs);
return true;
}
}
if (proxyMethod == null) return false;
return true;
}
示例14: GetDelegate
public static Delegate GetDelegate(MethodInfo openMethod, Type eventType, Type payloadType)
{
var closedMethod = openMethod.MakeGenericMethod(eventType);
return _cache.GetOrAdd(closedMethod, (m) =>
{
var param = Expression.Parameter(eventType);
var call = Expression.Call(param, closedMethod);
var lambda = Expression.Lambda(call, param);
return lambda.Compile();
});
}
示例15: GainMethod
internal MethodInfo GainMethod()
{
if (Info != null)
{
return Info;
}
Info = GainBase();
if(GenericParameter.Count > 0)
{
Info = Info.MakeGenericMethod(GenericParameter.GainTypes());
}
return Info;
}