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); }
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()); }
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); }
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(); }
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)); }
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); }
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); }
/// <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(); }
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(); }
bool CanCompareGenericMethods(MethodInfo a, MethodInfo b) { return AreEquivalentDefinitions(a, b) && TypesAreAllEquivalent(ParameterTypes(a), ParameterTypes(b)) && TypesAreAllEquivalent(a.GetGenericArguments(), b.GetGenericArguments()); }
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; }
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; }
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); }
/// <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; }
internal static string GetMethodSignature(System.Reflection.MethodInfo mi) { if (mi == null) { return(string.Empty); } StringBuilder sb = new StringBuilder(0x80); sb.Append(mi.Name); AppendGenericArguments(mi.GetGenericArguments(), sb); sb.Append("("); ParameterInfo[] parameters = mi.GetParameters(); foreach (ParameterInfo info in parameters) { AppendTypeName(info.ParameterType, false, sb); sb.Append(" " + info.Name); if ((info.Position + 1) < parameters.Length) { sb.Append(", "); } } sb.Append(")"); if (mi.ReturnType != typeof(void)) { StringBuilder builder2 = new StringBuilder(); AppendTypeName(mi.ReturnType, false, builder2); return(System.Design.SR.GetString("ObjectDataSourceMethodEditor_SignatureFormat", new object[] { sb, builder2 })); } return(sb.ToString()); }
/// <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; }
public static void EnsureSatisfiesClassConstraints(MethodInfo reflectionMethodInfo) { MethodInfo genericMethodDefinition = reflectionMethodInfo.GetGenericMethodDefinition(); TypeInfo[] methodArguments = TypesToTypeInfos(reflectionMethodInfo.GetGenericArguments()); TypeInfo[] methodParameters = TypesToTypeInfos(genericMethodDefinition.GetGenericArguments()); TypeInfo[] typeArguments = TypesToTypeInfos(reflectionMethodInfo.DeclaringType.GetGenericArguments()); SigTypeContext typeContext = new SigTypeContext(typeArguments, methodArguments); EnsureSatisfiesClassConstraints(methodParameters, methodArguments, genericMethodDefinition, typeContext); }
static string PrettyPrintGenericArguments(MethodInfo mi) { if (!mi.IsGenericMethodDefinition) { return ""; } return "<" + string.Join(", ", mi.GetGenericArguments().Select(ObjectToCode.GetCSharpFriendlyTypeName)) + ">"; }
public static IntPtr[] GenericMethodArguments(MethodInfo m) { Type[] types = m.GetGenericArguments(); IntPtr[] ptrTypes = new IntPtr[types.Length]; for (int i = 0; i < types.Length; i++) { ptrTypes [i] = types [i].TypeHandle.Value; } return ptrTypes; }
/// <summary> /// Initializes a new instance of the <see cref="MethodMatcher"/> class. /// </summary> /// <param name="methodInfo">The expected method reference.</param> public MethodMatcher(MethodInfo methodInfo) : base(methodInfo.Name, methodInfo.DeclaringType) { if (methodInfo == null) throw new ArgumentNullException("methodInfo"); _methodInfo = methodInfo; _genericParametersMatcher = new GenericMethodTypeParametersMatcher(_methodInfo.GetGenericArguments()); _expectedParameters = _methodInfo.GetParameters(); }
/// <summary> /// Returns first generic type argument of a type. /// </summary> /// <param name="type"></param> /// <returns>First generic type argument.</returns> public static Type GetFirstGenericTypeArgumentOfType(MethodInfo methodInfo) { if (!methodInfo.IsGenericMethod) { throw new OrmInternalException("The type of the query is not generic"); } return methodInfo.GetGenericArguments().First(); }
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; }
public Type[] GetGenericArgumentsFor(MethodInfo genericMethod) { List<Type> types = new List<Type>(); foreach(Type genType in genericMethod.GetGenericArguments()) { types.Add(name2GenericType[genType.Name]); } return types.ToArray(); }
private static string GetGenericParameterText( MethodInfo method ) { if( ! method.ContainsGenericParameters ) { return string.Empty; } Type[] genericParameters = method.GetGenericArguments(); string args = string.Join( ",", genericParameters.Select( t => t.Name() ) ); return "<" + args + ">"; }
public string Format(MethodInfo methodInfoOfCall, IEnumerable<object> arguments, IEnumerable<int> argumentsToHighlight) { string genericInfo = null; if (methodInfoOfCall.IsGenericMethod) { var genericArgs = methodInfoOfCall.GetGenericArguments(); genericInfo = "<" + string.Join(", ", genericArgs.Select(x => x.Name).ToArray()) + ">"; } return string.Format("{0}{1}({2})", methodInfoOfCall.Name, genericInfo, _argumentsFormatter.Format(arguments, argumentsToHighlight)); }
public bool InitializeProxyMethod(MethodInfo sourceMethod, Type[] types, out MethodInfo proxyMethod) { if (types == null) throw new ArgumentNullException("types"); var proxyTypeArgs = new List<Type>(); if (ReflectionHelper.IsGenericType(sourceMethod.DeclaringType)) { proxyTypeArgs.AddRange(sourceMethod.DeclaringType.GetGenericArguments()); } if (sourceMethod.IsGenericMethod) { proxyTypeArgs.AddRange(sourceMethod.GetGenericArguments()); } var typeArrayPointer = 0; var proxyType = this.ProxyType; if (proxyType.IsGenericTypeDefinition) { var typeArgs = new Type[proxyType.GetGenericArguments().Length]; for (int i = 0; i < typeArgs.Length; i++) { typeArgs[i] = proxyTypeArgs[typeArrayPointer]; typeArrayPointer++; } proxyType = proxyType.MakeGenericType(typeArgs); } if (proxyTypeArgs.Count > typeArrayPointer) { var methodParamArgs = new Type[proxyTypeArgs.Count - typeArrayPointer]; for (int i = 0; i < methodParamArgs.Length; i++) { methodParamArgs[i] = proxyTypeArgs[i + typeArrayPointer]; } proxyMethod = proxyType.GetMethods().Select(m => { if (m.IsGenericMethodDefinition && m.Name == MethodName) { var methodTypeParameters = m.GetGenericArguments(); if (methodTypeParameters.Length != methodParamArgs.Length) return null; var genericMethod = m.MakeGenericMethod(methodParamArgs); var parameters = genericMethod.GetParameters(); if (parameters.Length != types.Length) return null; for (int i = 0; i < parameters.Length; i++) { if (parameters[i].ParameterType != types[i]) return null; } return genericMethod; } return null; }).FirstOrDefault(m => m != null); } else { proxyMethod = proxyType.GetMethod(MethodName, types); } return proxyMethod != null; }
private static void BuildGenericArguments(MethodInfo method, StringBuilder builder) { builder.Append("<"); var genericArguments = new List<string>(); foreach (var argument in method.GetGenericArguments()) { genericArguments.Add(argument.Name); } builder.Append(string.Join(", ", genericArguments)); builder.Append(">"); }
/// <summary> /// Checks whether the provided method matches the expected generic argument types. /// </summary> /// <param name="method"></param> /// <param name="expectedArgumentTypes"></param> /// <returns></returns> public static bool ArgumentsMatch(MethodInfo method, Type[] expectedArgumentTypes) { bool argumentsMatch = true; // Disabled logging to boost performance //using (LogGroup logGroup = LogGroup.Start("Checking whether the provided arguments match those on the provided method.", LogLevel.Debug)) //{ if (method == null) throw new ArgumentNullException("method"); if (expectedArgumentTypes == null) throw new ArgumentNullException("expectedArgumentTypes"); // LogWriter.Debug("Method name: " + method.Name); // LogWriter.Debug("Method parent object: " + method.DeclaringType.FullName); Type[] argumentTypes = method.GetGenericArguments(); // LogWriter.Debug("Arguments on method: " + argumentTypes.Length); // LogWriter.Debug("Arguments expected: " + expectedArgumentTypes); if (argumentTypes.Length == expectedArgumentTypes.Length) { for (int i = 0; i < expectedArgumentTypes.Length; i++) { // Get the actual type of the argument Type actualType = argumentTypes[i]; if (actualType == null) throw new Exception("actualType == null"); if (actualType.FullName == string.Empty) throw new Exception("actualType.FullName == String.Empty"); // LogWriter.Debug("Comparing expected argument type '" + expectedArgumentTypes[i].FullName + "' with actual type '" + actualType.FullName + "'."); bool match = actualType.FullName == expectedArgumentTypes[i].FullName; bool isAssignable = actualType.IsAssignableFrom(expectedArgumentTypes[i]); // LogWriter.Debug("Match: " + match); // LogWriter.Debug("Is assignable: " + isAssignable); if (!(match || isAssignable)) argumentsMatch = false; } } else argumentsMatch = false; // LogWriter.Debug("Parameters match: " + argumentsMatch.ToString()); //} return argumentsMatch; }
/// <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); }
public bool MethodEquals(MethodDefinition md, MethodInfo mi) { if (!MemberEquals(md, mi) || !TypeEquals(md.ReturnType, mi.ReturnType) || (int)md.Attributes != (int)mi.Attributes) return false; var pis = mi.GetParameters(); if (md.Parameters.Count != pis.Length) return false; for (int i = 0; i < pis.Length; i++) if (!TypeEquals(md.Parameters[i].ParameterType, pis[i].ParameterType)) return false; if (!mi.IsGenericMethod) return md.GenericParameters.Count == 0; if (mi.GetGenericArguments().Length != md.GenericParameters.Count) return false; return mi.GetGenericArguments().Length == md.GenericParameters.Count; }
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; }
/// <summary> /// Processes the method generic parameters. /// </summary> /// <param name="m">The m.</param> /// <returns></returns> private IList <TypeModel> ProcessMethodGenericParameters(System.Reflection.MethodInfo m) { if (m.IsGenericMethod) { return(m.GetGenericArguments().Select(t => new TypeModel { BaseType = t, Name = t.ToSafeName() }).ToList()); } else { return(default(IList <TypeModel>)); } }
static StackObject *GetGenericArguments_9(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj) { ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain; StackObject *ptr_of_this_method; StackObject *__ret = ILIntepreter.Minus(__esp, 1); ptr_of_this_method = ILIntepreter.Minus(__esp, 1); System.Reflection.MethodInfo instance_of_this_method = (System.Reflection.MethodInfo) typeof(System.Reflection.MethodInfo).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack)); __intp.Free(ptr_of_this_method); var result_of_this_method = instance_of_this_method.GetGenericArguments(); return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method)); }
private System.Reflection.MethodInfo ReplaceAnonymousType(System.Reflection.MethodInfo methodInfo) { if (methodInfo.IsGenericMethod) { var args = from a in methodInfo.GetGenericArguments() select ReplaceAnonymousType(a); return(methodInfo.GetGenericMethodDefinition().MakeGenericMethod(args.ToArray())); } else { return(methodInfo); } }
private void addMethodCall(List <ParameterExpression> parameters, List <byte> result, IList <Expression> arguments, System.Reflection.MethodInfo method, Expression target) { result.Add((byte)ExpressionType.Call); if (target == null) { serialize(Expression.Constant(null, typeof(object)), parameters, result); } else { serialize(target, parameters, result); } addType(result, method.DeclaringType); addString(result, method.Name); addInt16(result, (short)arguments.Count); for (var i = 0; i < arguments.Count; i++) { serialize(arguments[i], parameters, result); } result.Add((byte)(method.IsConstructedGenericMethod ? 1 : 0)); if (method.IsConstructedGenericMethod) { var genericArguments = method.GetGenericArguments(); result.Add(checked ((byte)genericArguments.Length)); for (var i = 0; i < genericArguments.Length; i++) { addType(result, genericArguments[i]); } } }
/// <summary> /// Translates a SignatureType into its equivalent resolved Type by recursively substituting all generic parameter references /// with its corresponding generic parameter definition. This is slow so MatchesExactly or MatchesParameterTypeExactly should be /// substituted instead whenever possible. This is only used by the DefaultBinder when its fast-path checks have been exhausted and /// it needs to call non-trivial methods like IsAssignableFrom which SignatureTypes will never support. /// /// Because this method is used to eliminate method candidates in a GetMethod() lookup, it is entirely possible that the Type /// might not be creatable due to conflicting generic constraints. Since this merely implies that this candidate is not /// the method we're looking for, we return null rather than let the TypeLoadException bubble up. The DefaultBinder will catch /// the null and continue its search for a better candidate. /// </summary> internal static Type TryResolveAgainstGenericMethod(this SignatureType signatureType, MethodInfo genericMethod) { return(signatureType.TryResolve(genericMethod.GetGenericArguments())); }
static private IEnumerable <Instruction> Body(this MethodInfo method, byte[] buffer) { if (buffer == null) { yield break; } var _authority = new Authority(method); var _stream = new MemoryStream(buffer); var _reader = new BinaryReader(_stream); var _code = OpCodes.Nop; while (_stream.Position < _stream.Length) { var _byte = _reader.ReadByte(); if (_byte != 0xFE) { _code = ___MethodInfo.m_Single[_byte]; } else { _byte = _reader.ReadByte(); _code = ___MethodInfo.m_Double[_byte]; } switch (_code.OperandType) { case OperandType.InlineNone: yield return(new Instruction(_code, null, null)); break; case OperandType.ShortInlineBrTarget: yield return(new Instruction <Label>(_code, _reader.ReadShortLabel())); break; case OperandType.InlineBrTarget: yield return(new Instruction <Label>(_code, _reader.ReadLabel())); break; case OperandType.ShortInlineI: yield return(new Instruction <byte>(_code, _reader.ReadByte())); break; case OperandType.InlineI: yield return(new Instruction <int>(_code, _reader.ReadInt32())); break; case OperandType.InlineI8: yield return(new Instruction <long>(_code, _reader.ReadInt64())); break; case OperandType.ShortInlineR: yield return(new Instruction <float>(_code, _reader.ReadSingle())); break; case OperandType.InlineR: yield return(new Instruction <double>(_code, _reader.ReadDouble())); break; case OperandType.ShortInlineVar: yield return(new Instruction <byte>(_code, _reader.ReadByte())); break; case OperandType.InlineVar: yield return(new Instruction <short>(_code, _reader.ReadInt16())); break; case OperandType.InlineString: yield return(new Instruction <string>(_code, _authority.String(_reader.ReadInt32()))); break; case OperandType.InlineSig: yield return(new Instruction <byte[]>(_code, _authority.Signature(_reader.ReadInt32()))); break; case OperandType.InlineField: yield return(new Instruction <FieldInfo>(_code, _authority.Field(_reader.ReadInt32(), method.DeclaringType == null ? new Type[0] : method.DeclaringType.GetGenericArguments(), method.IsGenericMethod ? method.GetGenericArguments() : new Type[0]))); break; case OperandType.InlineMethod: var _method = _authority.Method(_reader.ReadInt32(), method.DeclaringType == null ? new Type[0] : method.DeclaringType.GetGenericArguments(), method.IsGenericMethod ? method.GetGenericArguments() : new Type[0]); if (_method is ConstructorInfo) { yield return(new Instruction <ConstructorInfo>(_code, (ConstructorInfo)_method)); } else { yield return(new Instruction <MethodInfo>(_code, (MethodInfo)_method)); } break; case OperandType.InlineType: yield return(new Instruction <Type>(_code, _authority.Type(_reader.ReadInt32(), method.DeclaringType == null ? new Type[0] : method.DeclaringType.GetGenericArguments(), method.IsGenericMethod ? method.GetGenericArguments() : new Type[0]))); break; case OperandType.InlineTok: var _member = (MemberInfo)_authority.Member(_reader.ReadInt32(), method.DeclaringType == null ? new Type[0] : method.DeclaringType.GetGenericArguments(), method.IsGenericMethod ? method.GetGenericArguments() : new Type[0]); if (_member is FieldInfo) { yield return(new Instruction <FieldInfo>(_code, (FieldInfo)_member)); } else if (_member is ConstructorInfo) { yield return(new Instruction <ConstructorInfo>(_code, (ConstructorInfo)_member)); } else if (_member is MethodInfo) { yield return(new Instruction <MethodInfo>(_code, (MethodInfo)_member)); } else if (_member is Type) { yield return(new Instruction <Type>(_code, (Type)_member)); } break; case OperandType.InlineSwitch: yield return(new Instruction <Label[]>(OpCodes.Switch, Enumerable.Range(0, Convert.ToInt32(_reader.ReadUInt32())).Select(_Iterator => _reader.ReadLabel()).ToArray())); break; default: throw new NotSupportedException(); } } }
/// <summary> /// Gets the full signature. /// </summary> /// <param name="This">This MethodInfo.</param> /// <returns>The full signature of the method.</returns> public static string GetFullSignature(this MethodInfo This) { #if NET40 Contract.Requires(This != null); #endif var sb = new StringBuilder(); if (This.IsPublic) { sb.Append("public "); } else if (This.IsPrivate) { sb.Append("private "); } else if (This.IsAssembly) { sb.Append("internal "); } else if (This.IsFamily) { sb.Append("protected "); } if (This.IsStatic) { sb.Append("static "); } if (This.IsFinal) { sb.Append("final "); } if (This.IsVirtual) { sb.Append("virtual "); } if (This.IsAbstract) { sb.Append("abstract "); } sb.Append(_tidyTypeName(This.ReturnType)); sb.Append(' '); sb.Append(This.DeclaringType.ToString()); sb.Append('.'); sb.Append(This.Name); var types = This.IsGenericMethod ? This.GetGenericArguments() : null; if (types != null) { sb.Append('<'); for (var j = 0; j < types.Length; j++) { if (j > 0) { sb.Append(", "); } sb.Append(_tidyTypeName(types[j])); } sb.Append('>'); } sb.Append('('); var pars = This.GetParameters(); var lastI = pars.Length - 1; for (var i = 0; i < pars.Length; i++) { if (i > 0) { sb.Append(", "); } var p = pars[i]; /*if (p.IsOptional) * sb.Append("optional "); */ var paramType = p.ParameterType; if (paramType.IsByRef) { sb.Append("ref "); } else if (p.IsOut) { sb.Append("out "); } if (i == lastI && paramType.IsArray) { sb.Append("params "); } sb.Append(_tidyTypeName(paramType) + ' '); sb.Append(p.Name); if (p.IsOptional) { sb.Append(" = " + (p.DefaultValue ?? "null")); } } sb.Append(')'); return(sb.ToString()); }
/// <summary> /// Return the method signature as a string. /// </summary> /// <param name="method">The Method</param> /// <param name="callable">Return as an callable string(public void a(string b) would return a(b))</param> /// <returns>Method signature</returns> public static string GetSignature(this MethodInfo method, bool callable = false) { var firstParam = true; var sigBuilder = new StringBuilder(); if (callable == false) { if (method.IsPublic) { sigBuilder.Append("public "); } else if (method.IsPrivate) { sigBuilder.Append("private "); } else if (method.IsAssembly) { sigBuilder.Append("internal "); } if (method.IsFamily) { sigBuilder.Append("protected "); } if (method.IsStatic) { sigBuilder.Append("static "); } sigBuilder.Append(TypeName(method.ReturnType)); sigBuilder.Append(' '); } sigBuilder.Append(method.Name); // Add method generics if (method.IsGenericMethod) { sigBuilder.Append("<"); foreach (var g in method.GetGenericArguments()) { if (firstParam) { firstParam = false; } else { sigBuilder.Append(", "); } sigBuilder.Append(TypeName(g)); } sigBuilder.Append(">"); } sigBuilder.Append("("); firstParam = true; var secondParam = false; foreach (var param in method.GetParameters()) { if (firstParam) { firstParam = false; if (method.IsDefined(typeof(System.Runtime.CompilerServices.ExtensionAttribute), false)) { if (callable) { secondParam = true; continue; } sigBuilder.Append("this "); } } else if (secondParam == true) { secondParam = false; } else { sigBuilder.Append(", "); } if (param.ParameterType.IsByRef) { sigBuilder.Append("ref "); } else if (param.IsOut) { sigBuilder.Append("out "); } if (!callable) { sigBuilder.Append(TypeName(param.ParameterType)); sigBuilder.Append(' '); } sigBuilder.Append(param.Name); } sigBuilder.Append(")"); return(sigBuilder.ToString()); }
public void PrintMethod(SysRef.MethodInfo method) { if (method.IsStatic) { _builder.Append("static "); } var callConv = method.CallingConvention; if ((callConv & SysRef.CallingConventions.VarArgs) == SysRef.CallingConventions.VarArgs) { _builder.Append("vararg "); } // Owner if ((_flags & SignaturePrintingFlags.IgnoreMemberOwner) != SignaturePrintingFlags.IgnoreMemberOwner) { PrintType(method.DeclaringType); _builder.Append("::"); } // Name PrintIdentifier(method.Name); // Generic arguments { var genericArguments = method.GetGenericArguments(); if (genericArguments.Length > 0) { _builder.Append("<"); for (int i = 0; i < genericArguments.Length; i++) { if (i > 0) { _builder.Append(", "); } PrintType(genericArguments[i], false); } _builder.Append(">"); } } // Parameters { var parameters = method.GetParameters(); _builder.Append("("); for (int i = 0; i < parameters.Length; i++) { if (i > 0) { _builder.Append(", "); } PrintType(parameters[i].ParameterType, false); } _builder.Append(")"); } // Return type _builder.Append(" : "); PrintType(method.ReturnType, false); }
/// <summary> /// Translates a SignatureType into its equivalent resolved Type by recursively substituting all generic parameter references /// with its corresponding generic parameter definition. This is slow so MatchesExactly or MatchesParameterTypeExactly should be /// substituted instead whenever possible. This is only used by the DefaultBinder when its fast-path checks have been exhausted and /// it needs to call non-trivial methods like IsAssignableFrom which SignatureTypes will never support. /// /// Because this method is used to eliminate method candidates in a GetMethod() lookup, it is entirely possible that the Type /// might not be creatable due to conflicting generic constraints. Since this merely implies that this candidate is not /// the method we're looking for, we return null rather than let the TypeLoadException bubble up. The DefaultBinder will catch /// the null and continue its search for a better candidate. /// </summary> internal static Type?TryResolveAgainstGenericMethod(this Type signatureType, MethodInfo genericMethod) { Debug.Assert(signatureType.IsSignatureType()); return(signatureType.TryResolve(genericMethod.GetGenericArguments())); }
public static void GetSerializationInfo(SerializationInfo info, MethodInfo m) { Type[] genericArguments = m.IsConstructedGenericMethod ? m.GetGenericArguments() : null; GetSerializationInfo(info, m.Name, m.ReflectedType, m.ToString(), m.SerializationToString(), MemberTypes.Method, genericArguments); }
private MethodBuilder AddMethodImpl(MethodInfo mi) { ParameterInfo[] parameters = mi.GetParameters(); Type[] paramTypes = ParamTypes(parameters, false); MethodBuilder mdb = _tb.DefineMethod(mi.Name, MethodAttributes.Public | MethodAttributes.Virtual, mi.ReturnType, paramTypes); if (mi.ContainsGenericParameters) { Type[] ts = mi.GetGenericArguments(); string[] ss = new string[ts.Length]; for (int i = 0; i < ts.Length; i++) { ss[i] = ts[i].Name; } GenericTypeParameterBuilder[] genericParameters = mdb.DefineGenericParameters(ss); for (int i = 0; i < genericParameters.Length; i++) { genericParameters[i].SetGenericParameterAttributes(ts[i].GetTypeInfo().GenericParameterAttributes); } } ILGenerator il = mdb.GetILGenerator(); ParametersArray args = new ParametersArray(il, paramTypes); // object[] args = new object[paramCount]; il.Emit(OpCodes.Nop); GenericArray <object> argsArr = new GenericArray <object>(il, ParamTypes(parameters, true).Length); for (int i = 0; i < parameters.Length; i++) { // args[i] = argi; if (!parameters[i].IsOut) { argsArr.BeginSet(i); args.Get(i); argsArr.EndSet(parameters[i].ParameterType); } } // object[] packed = new object[PackedArgs.PackedTypes.Length]; GenericArray <object> packedArr = new GenericArray <object>(il, PackedArgs.PackedTypes.Length); // packed[PackedArgs.DispatchProxyPosition] = this; packedArr.BeginSet(PackedArgs.DispatchProxyPosition); il.Emit(OpCodes.Ldarg_0); packedArr.EndSet(typeof(DispatchProxy)); // packed[PackedArgs.DeclaringTypePosition] = typeof(iface); MethodInfo Type_GetTypeFromHandle = typeof(Type).GetRuntimeMethod("GetTypeFromHandle", new Type[] { typeof(RuntimeTypeHandle) }); int methodToken; Type declaringType; _assembly.GetTokenForMethod(mi, out declaringType, out methodToken); packedArr.BeginSet(PackedArgs.DeclaringTypePosition); il.Emit(OpCodes.Ldtoken, declaringType); il.Emit(OpCodes.Call, Type_GetTypeFromHandle); packedArr.EndSet(typeof(object)); // packed[PackedArgs.MethodTokenPosition] = iface method token; packedArr.BeginSet(PackedArgs.MethodTokenPosition); il.Emit(OpCodes.Ldc_I4, methodToken); packedArr.EndSet(typeof(Int32)); // packed[PackedArgs.ArgsPosition] = args; packedArr.BeginSet(PackedArgs.ArgsPosition); argsArr.Load(); packedArr.EndSet(typeof(object[])); // packed[PackedArgs.GenericTypesPosition] = mi.GetGenericArguments(); if (mi.ContainsGenericParameters) { packedArr.BeginSet(PackedArgs.GenericTypesPosition); Type[] genericTypes = mi.GetGenericArguments(); GenericArray <Type> typeArr = new GenericArray <Type>(il, genericTypes.Length); for (int i = 0; i < genericTypes.Length; ++i) { typeArr.BeginSet(i); il.Emit(OpCodes.Ldtoken, genericTypes[i]); il.Emit(OpCodes.Call, Type_GetTypeFromHandle); typeArr.EndSet(typeof(Type)); } typeArr.Load(); packedArr.EndSet(typeof(Type[])); } // Call static DispatchProxyHelper.Invoke(object[]) il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldfld, _fields[InvokeActionFieldAndCtorParameterIndex]); // delegate packedArr.Load(); il.Emit(OpCodes.Call, s_delegateInvoke); for (int i = 0; i < parameters.Length; i++) { if (parameters[i].ParameterType.IsByRef) { args.BeginSet(i); argsArr.Get(i); args.EndSet(i, typeof(object)); } } if (mi.ReturnType != typeof(void)) { packedArr.Get(PackedArgs.ReturnValuePosition); Convert(il, typeof(object), mi.ReturnType, false); } il.Emit(OpCodes.Ret); _tb.DefineMethodOverride(mdb, mi); return(mdb); }