本文整理汇总了C#中System.Reflection.MethodInfo.GetGenericArguments方法的典型用法代码示例。如果您正苦于以下问题:C# MethodInfo.GetGenericArguments方法的具体用法?C# MethodInfo.GetGenericArguments怎么用?C# MethodInfo.GetGenericArguments使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类System.Reflection.MethodInfo
的用法示例。
在下文中一共展示了MethodInfo.GetGenericArguments方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: CreateProxiedMethod
public void CreateProxiedMethod(FieldInfo field, MethodInfo method, TypeBuilder typeBuilder)
{
const MethodAttributes methodAttributes = MethodAttributes.Public | MethodAttributes.HideBySig |
MethodAttributes.Virtual;
ParameterInfo[] parameters = method.GetParameters();
MethodBuilder methodBuilder = typeBuilder.DefineMethod(method.Name, methodAttributes,
CallingConventions.HasThis, method.ReturnType,
parameters.Select(param => param.ParameterType).ToArray());
System.Type[] typeArgs = method.GetGenericArguments();
if (typeArgs.Length > 0)
{
var typeNames = new List<string>();
for (int index = 0; index < typeArgs.Length; index++)
{
typeNames.Add(string.Format("T{0}", index));
}
methodBuilder.DefineGenericParameters(typeNames.ToArray());
}
ILGenerator IL = methodBuilder.GetILGenerator();
Debug.Assert(MethodBodyEmitter != null);
MethodBodyEmitter.EmitMethodBody(IL, method, field);
}
示例2: IsSameMethod
private static bool IsSameMethod(MethodInfo first, MethodInfo second)
{
return first.DeclaringType == second.DeclaringType
&& first.MetadataToken == second.MetadataToken
&& first.Module == second.Module
&& first.GetGenericArguments().SequenceEqual(second.GetGenericArguments());
}
示例3: GetMethodDefinition
public IAutoFactoryMethodDefinition GetMethodDefinition(MethodInfo methodInfo, IList<object> arguments)
{
if (methodInfo.Name.StartsWith("GetNames", StringComparison.InvariantCultureIgnoreCase)
&& methodInfo.IsGenericMethod
&& methodInfo.GetGenericArguments().Any()
&& (methodInfo.ReturnType.IsAssignableFrom(typeof(List<string>))))
{
return new AutoFactoryMethodDefinition(AutoFactoryMethodType.GetNames, methodInfo.GetGenericArguments().First(), null, null);
}
var pluginType = methodInfo.ReturnType;
// do nothing with void methods for now
if (pluginType == typeof(void))
{
return null;
}
var name = tryGetInstanceName(methodInfo, arguments);
var isNamed = !string.IsNullOrEmpty(name);
var explicitArguments = getExplicitArguments(isNamed, methodInfo, arguments);
return new AutoFactoryMethodDefinition(AutoFactoryMethodType.GetInstance, pluginType, name, explicitArguments);
}
示例4: GetComponentType
protected override Type GetComponentType(MethodInfo method, object[] arguments)
{
int genericLength = method.GetGenericArguments().Length;
if (genericLength == 1)
{
bool isView = typeof (IView).IsAssignableFrom(method.GetGenericArguments()[0]);
if (method.Name == "CreatePresenter" && isView)
{
return method.GetGenericArguments()[0];
}
}
return base.GetComponentType(method, arguments);
}
示例5: GetGenericDeclarationInformation
protected static string GetGenericDeclarationInformation(MethodInfo method, Assembly containingAssembly, bool isDeclaration)
{
var builder = new StringBuilder();
if(method != null)
{
var genericArguments = method.GetGenericArguments();
builder.Append("<");
var descriptors = new List<string>();
if(genericArguments != null)
{
foreach(var genericArgument in genericArguments)
{
var elementType = genericArgument.GetRootElementType();
if(isDeclaration)
{
descriptors.Add(elementType.Name);
}
else
{
descriptors.Add(new TypeDescriptor(elementType, containingAssembly, true).Value);
}
}
}
builder.Append(string.Join(", ", descriptors.ToArray()));
builder.Append(">");
}
return builder.ToString();
}
示例6: CloneGenericMethodArguments
protected static GenericTypeParameterBuilder[] CloneGenericMethodArguments(MethodInfo source, MethodBuilder destination)
{
var genericArgs = source.GetGenericArguments();
if (genericArgs.Length == 0)
{
return new GenericTypeParameterBuilder[0];
}
var names = new string[genericArgs.Length];
for (var i = 0; i < genericArgs.Length; i++)
{
names[i] = genericArgs[i].Name;
}
var genericTypeParameterBuilders = destination.DefineGenericParameters(names);
for (var i = 0; i < genericTypeParameterBuilders.Length; i++)
{
var genericArgConstraints = genericArgs[i].GetGenericParameterConstraints();
for (var j = 0; j < genericArgConstraints.Length; j++)
{
genericTypeParameterBuilders[i].SetBaseTypeConstraint(genericArgConstraints[j]);
}
}
return genericTypeParameterBuilders;
}
示例7: VisitMethod
protected virtual MethodInfo VisitMethod(MethodInfo methodToSearch)
{
var newReflectedType = VisitType(methodToSearch.ReflectedType);
if (newReflectedType != methodToSearch.ReflectedType)
{
methodToSearch = newReflectedType.GetMethod(methodToSearch.Name,
(methodToSearch.IsStatic ? BindingFlags.Static : BindingFlags.Instance)
| (methodToSearch.IsPublic
? BindingFlags.Public
: BindingFlags.NonPublic),
null,
methodToSearch.GetParameters().Select(x => x.ParameterType).ToArray(),
null);
}
if (!methodToSearch.IsGenericMethod)
return methodToSearch;
var genArgs = methodToSearch.GetGenericArguments();
var newGenArgs = genArgs.Select(VisitType).ToArray();
if (genArgs.SequenceEqual(newGenArgs))
return methodToSearch;
return methodToSearch.GetGenericMethodDefinition().MakeGenericMethod(newGenArgs);
}
示例8: CreateMethod
public static Method CreateMethod(MethodInfo methodInfo, TsType parent)
{
var method = new Method(methodInfo.Name, parent)
{
IsStatic = methodInfo.IsStatic
};
var parameters = methodInfo.GetParameters();
foreach (var parameterInfo in parameters)
{
method.Parameters.Add(MethodParameterFactory.Create(parameterInfo, method));
}
if (methodInfo.IsGenericMethod)
{
var genericArguments = methodInfo.GetGenericArguments();
foreach (var argument in genericArguments)
{
method.Generics.Add(new GenericDefinition(argument.Name));
}
}
if (methodInfo.ReturnType != typeof(void))
{
method.Return = new TsUndefined { UnderlyingType = methodInfo.ReturnType };
}
return method;
}
示例9: CanCompareGenericMethods
bool CanCompareGenericMethods(MethodInfo a, MethodInfo b)
{
return
AreEquivalentDefinitions(a, b)
&& TypesAreAllEquivalent(ParameterTypes(a), ParameterTypes(b))
&& TypesAreAllEquivalent(a.GetGenericArguments(), b.GetGenericArguments());
}
示例10: GenerateMethod
public virtual void GenerateMethod(PropertyInfo pi, MethodInfo mi, ILGenerator gen)
{
gen.DeclareLocal(typeof(Type));
gen.EmitLdType(mi.GetGenericArguments()[0]);
gen.Emit(OpCodes.Stloc_0);
foreach (var scc in _pcb.ProxyCoderContext.MixinCoderContexts.SelectMany(a => a.SubjectCoderContexts))
{
var smes = scc.GetPerSubjectCoder<ISubjectMethodExistsPerSubjectCoder>();
if (smes==null)
continue;
var falseTarget = gen.DefineLabel();
gen.Emit(OpCodes.Ldloc_0);
gen.EmitLdType(scc.SubjectType);
gen.EmitOpEqualityCall(typeof(Type));
gen.Emit(OpCodes.Brfalse, falseTarget);
smes.PutSubjectMethodExistsOnStack(gen);
// Required for PE Verification
gen.Emit(OpCodes.Castclass, mi.ReturnType);
gen.Emit(OpCodes.Ret);
gen.MarkLabel(falseTarget);
}
gen.Emit(OpCodes.Ldnull);
gen.Emit(OpCodes.Ret);
}
示例11: 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));
}
示例12: ResolveTypeArguments
public static Type[] ResolveTypeArguments(MethodInfo method, object[] parameters)
{
var genericArguments = method.GetGenericArguments();
var parameterTypes = method.GetParameters().Select(p => p.ParameterType).ToArray();
return genericArguments.Select(genericArgument => ResolveTypeArgument(genericArgument, parameterTypes, parameters)).ToArray();
}
示例13: GetDisplayName
/// <summary>
/// Gets the display name for a method as used by NUnit.
/// </summary>
/// <param name="method">The method for which a display name is needed.</param>
/// <param name="arglist">The arguments provided.</param>
/// <returns>The display name for the method</returns>
public static string GetDisplayName(MethodInfo method, object[] arglist)
{
StringBuilder sb = new StringBuilder(method.Name);
#if CLR_2_0 || CLR_4_0
if (method.IsGenericMethod)
{
sb.Append("<");
int cnt = 0;
foreach (Type t in method.GetGenericArguments())
{
if (cnt++ > 0) sb.Append(",");
sb.Append(t.Name);
}
sb.Append(">");
}
#endif
if (arglist != null)
{
sb.Append("(");
for (int i = 0; i < arglist.Length; i++)
{
if (i > 0) sb.Append(",");
sb.Append(GetDisplayString(arglist[i]));
}
sb.Append(")");
}
return sb.ToString();
}
示例14: ImplementEmptyStubMethod
/// <summary>
/// Implements a method as a no operation method. Method can be virtual, abstract or not.
/// </summary>
/// <param name="tB">The <see cref="TypeBuilder"/> for the new type.</param>
/// <param name="method">The method to implement.</param>
/// <param name="isVirtual">Defaults to false: the method is sealed. True to keep the method virtual. </param>
/// <returns>The <see cref="MethodBuilder"/> to enable, for instance, creation of custom attributes on the method.</returns>
public static MethodBuilder ImplementEmptyStubMethod( TypeBuilder tB, MethodInfo method, bool isVirtual = false )
{
if( tB == null ) throw new ArgumentNullException( "tB" );
if( method == null ) throw new ArgumentNullException( "method" );
ParameterInfo[] parameters = method.GetParameters();
Type[] parametersTypes = ReflectionHelper.CreateParametersType( parameters );
Type returnType = method.ReturnType;
MethodAttributes mA = method.Attributes & ~(MethodAttributes.Abstract | MethodAttributes.VtableLayoutMask);
if( isVirtual ) mA |= MethodAttributes.Virtual;
MethodBuilder mB = tB.DefineMethod( method.Name, mA );
if( method.ContainsGenericParameters )
{
int i = 0;
Type[] genericArguments = method.GetGenericArguments();
string[] names = genericArguments.Select( t => String.Format( "T{0}", i++ ) ).ToArray();
var genericParameters = mB.DefineGenericParameters( names );
for( i = 0; i < names.Length; ++i )
{
var genericTypeArgument = genericArguments[i].GetTypeInfo();
GenericTypeParameterBuilder genericTypeBuilder = genericParameters[i];
genericTypeBuilder.SetGenericParameterAttributes( genericTypeArgument.GenericParameterAttributes );
genericTypeBuilder.SetInterfaceConstraints( genericTypeArgument.GetGenericParameterConstraints() );
}
}
mB.SetReturnType( method.ReturnType );
mB.SetParameters( ReflectionHelper.CreateParametersType( parameters ) );
EmitEmptyImplementation( mB, returnType, parameters );
return mB;
}
示例15: MethodInvokeInfo
/// <summary>
/// Initializes a new instance of the <see cref="MethodInvokeInfo"/> class.
/// </summary>
/// <param name="method">The method.</param>
public MethodInvokeInfo(MethodInfo method)
{
name = method.Name;
declaringType = method.DeclaringType;
genericArguments = method.GetGenericArguments();
parameters = method.GetParameters();
returnType = method.ReturnType;
}