summaryrefslogtreecommitdiff
path: root/src/mscorlib/src/System/Reflection/RuntimeMethodInfo.cs
diff options
context:
space:
mode:
Diffstat (limited to 'src/mscorlib/src/System/Reflection/RuntimeMethodInfo.cs')
-rw-r--r--src/mscorlib/src/System/Reflection/RuntimeMethodInfo.cs803
1 files changed, 803 insertions, 0 deletions
diff --git a/src/mscorlib/src/System/Reflection/RuntimeMethodInfo.cs b/src/mscorlib/src/System/Reflection/RuntimeMethodInfo.cs
new file mode 100644
index 0000000000..b8a2341e4e
--- /dev/null
+++ b/src/mscorlib/src/System/Reflection/RuntimeMethodInfo.cs
@@ -0,0 +1,803 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Diagnostics.Contracts;
+using System.Globalization;
+using System.Runtime.Serialization;
+using System.Security;
+using System.Text;
+using System.Threading;
+using RuntimeTypeCache = System.RuntimeType.RuntimeTypeCache;
+
+namespace System.Reflection
+{
+ [Serializable]
+ internal sealed class RuntimeMethodInfo : MethodInfo, ISerializable, IRuntimeMethodInfo
+ {
+ #region Private Data Members
+ private IntPtr m_handle;
+ private RuntimeTypeCache m_reflectedTypeCache;
+ private string m_name;
+ private string m_toString;
+ private ParameterInfo[] m_parameters;
+ private ParameterInfo m_returnParameter;
+ private BindingFlags m_bindingFlags;
+ private MethodAttributes m_methodAttributes;
+ private Signature m_signature;
+ private RuntimeType m_declaringType;
+ private object m_keepalive;
+ private INVOCATION_FLAGS m_invocationFlags;
+
+ internal INVOCATION_FLAGS InvocationFlags
+ {
+ get
+ {
+ if ((m_invocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_INITIALIZED) == 0)
+ {
+ INVOCATION_FLAGS invocationFlags = INVOCATION_FLAGS.INVOCATION_FLAGS_UNKNOWN;
+
+ Type declaringType = DeclaringType;
+
+ //
+ // first take care of all the NO_INVOKE cases.
+ if (ContainsGenericParameters ||
+ ReturnType.IsByRef ||
+ (declaringType != null && declaringType.ContainsGenericParameters) ||
+ ((CallingConvention & CallingConventions.VarArgs) == CallingConventions.VarArgs) ||
+ ((Attributes & MethodAttributes.RequireSecObject) == MethodAttributes.RequireSecObject))
+ {
+ // We don't need other flags if this method cannot be invoked
+ invocationFlags = INVOCATION_FLAGS.INVOCATION_FLAGS_NO_INVOKE;
+ }
+ else
+ {
+ // this should be an invocable method, determine the other flags that participate in invocation
+ invocationFlags = RuntimeMethodHandle.GetSecurityFlags(this);
+
+ if ((invocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_NEED_SECURITY) == 0)
+ {
+ if ((Attributes & MethodAttributes.MemberAccessMask) != MethodAttributes.Public ||
+ (declaringType != null && declaringType.NeedsReflectionSecurityCheck))
+ {
+ // If method is non-public, or declaring type is not visible
+ invocationFlags |= INVOCATION_FLAGS.INVOCATION_FLAGS_NEED_SECURITY;
+ }
+ else if (IsGenericMethod)
+ {
+ Type[] genericArguments = GetGenericArguments();
+
+ for (int i = 0; i < genericArguments.Length; i++)
+ {
+ if (genericArguments[i].NeedsReflectionSecurityCheck)
+ {
+ invocationFlags |= INVOCATION_FLAGS.INVOCATION_FLAGS_NEED_SECURITY;
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ m_invocationFlags = invocationFlags | INVOCATION_FLAGS.INVOCATION_FLAGS_INITIALIZED;
+ }
+
+ return m_invocationFlags;
+ }
+ }
+ #endregion
+
+ #region Constructor
+ internal RuntimeMethodInfo(
+ RuntimeMethodHandleInternal handle, RuntimeType declaringType,
+ RuntimeTypeCache reflectedTypeCache, MethodAttributes methodAttributes, BindingFlags bindingFlags, object keepalive)
+ {
+ Contract.Ensures(!m_handle.IsNull());
+
+ Debug.Assert(!handle.IsNullHandle());
+ Debug.Assert(methodAttributes == RuntimeMethodHandle.GetAttributes(handle));
+
+ m_bindingFlags = bindingFlags;
+ m_declaringType = declaringType;
+ m_keepalive = keepalive;
+ m_handle = handle.Value;
+ m_reflectedTypeCache = reflectedTypeCache;
+ m_methodAttributes = methodAttributes;
+ }
+ #endregion
+
+ #region Private Methods
+ RuntimeMethodHandleInternal IRuntimeMethodInfo.Value
+ {
+ get
+ {
+ return new RuntimeMethodHandleInternal(m_handle);
+ }
+ }
+
+ private RuntimeType ReflectedTypeInternal
+ {
+ get
+ {
+ return m_reflectedTypeCache.GetRuntimeType();
+ }
+ }
+
+ private ParameterInfo[] FetchNonReturnParameters()
+ {
+ if (m_parameters == null)
+ m_parameters = RuntimeParameterInfo.GetParameters(this, this, Signature);
+
+ return m_parameters;
+ }
+
+ private ParameterInfo FetchReturnParameter()
+ {
+ if (m_returnParameter == null)
+ m_returnParameter = RuntimeParameterInfo.GetReturnParameter(this, this, Signature);
+
+ return m_returnParameter;
+ }
+ #endregion
+
+ #region Internal Members
+ internal override string FormatNameAndSig(bool serialization)
+ {
+ // Serialization uses ToString to resolve MethodInfo overloads.
+ StringBuilder sbName = new StringBuilder(Name);
+
+ // serialization == true: use unambiguous (except for assembly name) type names to distinguish between overloads.
+ // serialization == false: use basic format to maintain backward compatibility of MethodInfo.ToString().
+ TypeNameFormatFlags format = serialization ? TypeNameFormatFlags.FormatSerialization : TypeNameFormatFlags.FormatBasic;
+
+ if (IsGenericMethod)
+ sbName.Append(RuntimeMethodHandle.ConstructInstantiation(this, format));
+
+ sbName.Append("(");
+ sbName.Append(ConstructParameters(GetParameterTypes(), CallingConvention, serialization));
+ sbName.Append(")");
+
+ return sbName.ToString();
+ }
+
+ internal override bool CacheEquals(object o)
+ {
+ RuntimeMethodInfo m = o as RuntimeMethodInfo;
+
+ if ((object)m == null)
+ return false;
+
+ return m.m_handle == m_handle;
+ }
+
+ internal Signature Signature
+ {
+ get
+ {
+ if (m_signature == null)
+ m_signature = new Signature(this, m_declaringType);
+
+ return m_signature;
+ }
+ }
+
+ internal BindingFlags BindingFlags { get { return m_bindingFlags; } }
+
+ internal RuntimeMethodInfo GetParentDefinition()
+ {
+ if (!IsVirtual || m_declaringType.IsInterface)
+ return null;
+
+ RuntimeType parent = (RuntimeType)m_declaringType.BaseType;
+
+ if (parent == null)
+ return null;
+
+ int slot = RuntimeMethodHandle.GetSlot(this);
+
+ if (RuntimeTypeHandle.GetNumVirtuals(parent) <= slot)
+ return null;
+
+ return (RuntimeMethodInfo)RuntimeType.GetMethodBase(parent, RuntimeTypeHandle.GetMethodAt(parent, slot));
+ }
+
+ // Unlike DeclaringType, this will return a valid type even for global methods
+ internal RuntimeType GetDeclaringTypeInternal()
+ {
+ return m_declaringType;
+ }
+
+ #endregion
+
+ #region Object Overrides
+ public override String ToString()
+ {
+ if (m_toString == null)
+ m_toString = ReturnType.FormatTypeName() + " " + FormatNameAndSig();
+
+ return m_toString;
+ }
+
+ public override int GetHashCode()
+ {
+ // See RuntimeMethodInfo.Equals() below.
+ if (IsGenericMethod)
+ return ValueType.GetHashCodeOfPtr(m_handle);
+ else
+ return base.GetHashCode();
+ }
+
+ public override bool Equals(object obj)
+ {
+ if (!IsGenericMethod)
+ return obj == (object)this;
+
+ // We cannot do simple object identity comparisons for generic methods.
+ // Equals will be called in CerHashTable when RuntimeType+RuntimeTypeCache.GetGenericMethodInfo()
+ // retrieve items from and insert items into s_methodInstantiations which is a CerHashtable.
+
+ RuntimeMethodInfo mi = obj as RuntimeMethodInfo;
+
+ if (mi == null || !mi.IsGenericMethod)
+ return false;
+
+ // now we know that both operands are generic methods
+
+ IRuntimeMethodInfo handle1 = RuntimeMethodHandle.StripMethodInstantiation(this);
+ IRuntimeMethodInfo handle2 = RuntimeMethodHandle.StripMethodInstantiation(mi);
+ if (handle1.Value.Value != handle2.Value.Value)
+ return false;
+
+ Type[] lhs = GetGenericArguments();
+ Type[] rhs = mi.GetGenericArguments();
+
+ if (lhs.Length != rhs.Length)
+ return false;
+
+ for (int i = 0; i < lhs.Length; i++)
+ {
+ if (lhs[i] != rhs[i])
+ return false;
+ }
+
+ if (DeclaringType != mi.DeclaringType)
+ return false;
+
+ if (ReflectedType != mi.ReflectedType)
+ return false;
+
+ return true;
+ }
+ #endregion
+
+ #region ICustomAttributeProvider
+ public override Object[] GetCustomAttributes(bool inherit)
+ {
+ return CustomAttribute.GetCustomAttributes(this, typeof(object) as RuntimeType as RuntimeType, inherit);
+ }
+
+ public override Object[] GetCustomAttributes(Type attributeType, bool inherit)
+ {
+ if (attributeType == null)
+ throw new ArgumentNullException(nameof(attributeType));
+ Contract.EndContractBlock();
+
+ RuntimeType attributeRuntimeType = attributeType.UnderlyingSystemType as RuntimeType;
+
+ if (attributeRuntimeType == null)
+ throw new ArgumentException(SR.Arg_MustBeType, nameof(attributeType));
+
+ return CustomAttribute.GetCustomAttributes(this, attributeRuntimeType, inherit);
+ }
+
+ public override bool IsDefined(Type attributeType, bool inherit)
+ {
+ if (attributeType == null)
+ throw new ArgumentNullException(nameof(attributeType));
+ Contract.EndContractBlock();
+
+ RuntimeType attributeRuntimeType = attributeType.UnderlyingSystemType as RuntimeType;
+
+ if (attributeRuntimeType == null)
+ throw new ArgumentException(SR.Arg_MustBeType, nameof(attributeType));
+
+ return CustomAttribute.IsDefined(this, attributeRuntimeType, inherit);
+ }
+
+ public override IList<CustomAttributeData> GetCustomAttributesData()
+ {
+ return CustomAttributeData.GetCustomAttributesInternal(this);
+ }
+ #endregion
+
+ #region MemberInfo Overrides
+ public override String Name
+ {
+ get
+ {
+ if (m_name == null)
+ m_name = RuntimeMethodHandle.GetName(this);
+
+ return m_name;
+ }
+ }
+
+ public override Type DeclaringType
+ {
+ get
+ {
+ if (m_reflectedTypeCache.IsGlobal)
+ return null;
+
+ return m_declaringType;
+ }
+ }
+
+ public override Type ReflectedType
+ {
+ get
+ {
+ if (m_reflectedTypeCache.IsGlobal)
+ return null;
+
+ return m_reflectedTypeCache.GetRuntimeType();
+ }
+ }
+
+ public override MemberTypes MemberType { get { return MemberTypes.Method; } }
+ public override int MetadataToken
+ {
+ get { return RuntimeMethodHandle.GetMethodDef(this); }
+ }
+ public override Module Module { get { return GetRuntimeModule(); } }
+ internal RuntimeType GetRuntimeType() { return m_declaringType; }
+ internal RuntimeModule GetRuntimeModule() { return m_declaringType.GetRuntimeModule(); }
+ internal RuntimeAssembly GetRuntimeAssembly() { return GetRuntimeModule().GetRuntimeAssembly(); }
+
+ public override bool IsSecurityCritical
+ {
+ get { return true; }
+ }
+ public override bool IsSecuritySafeCritical
+ {
+ get { return false; }
+ }
+ public override bool IsSecurityTransparent
+ {
+ get { return false; }
+ }
+ #endregion
+
+ #region MethodBase Overrides
+ internal override ParameterInfo[] GetParametersNoCopy()
+ {
+ FetchNonReturnParameters();
+
+ return m_parameters;
+ }
+
+ [System.Diagnostics.Contracts.Pure]
+ public override ParameterInfo[] GetParameters()
+ {
+ FetchNonReturnParameters();
+
+ if (m_parameters.Length == 0)
+ return m_parameters;
+
+ ParameterInfo[] ret = new ParameterInfo[m_parameters.Length];
+
+ Array.Copy(m_parameters, ret, m_parameters.Length);
+
+ return ret;
+ }
+
+ public override MethodImplAttributes GetMethodImplementationFlags()
+ {
+ return RuntimeMethodHandle.GetImplAttributes(this);
+ }
+
+ public override RuntimeMethodHandle MethodHandle
+ {
+ get
+ {
+ Type declaringType = DeclaringType;
+ if ((declaringType == null && Module.Assembly.ReflectionOnly) || declaringType is ReflectionOnlyType)
+ throw new InvalidOperationException(SR.InvalidOperation_NotAllowedInReflectionOnly);
+ return new RuntimeMethodHandle(this);
+ }
+ }
+
+ public override MethodAttributes Attributes { get { return m_methodAttributes; } }
+
+ public override CallingConventions CallingConvention
+ {
+ get
+ {
+ return Signature.CallingConvention;
+ }
+ }
+
+ public override MethodBody GetMethodBody()
+ {
+ MethodBody mb = RuntimeMethodHandle.GetMethodBody(this, ReflectedTypeInternal);
+ if (mb != null)
+ mb.m_methodBase = this;
+ return mb;
+ }
+ #endregion
+
+ #region Invocation Logic(On MemberBase)
+ private void CheckConsistency(Object target)
+ {
+ // only test instance methods
+ if ((m_methodAttributes & MethodAttributes.Static) != MethodAttributes.Static)
+ {
+ if (!m_declaringType.IsInstanceOfType(target))
+ {
+ if (target == null)
+ throw new TargetException(SR.RFLCT_Targ_StatMethReqTarg);
+ else
+ throw new TargetException(SR.RFLCT_Targ_ITargMismatch);
+ }
+ }
+ }
+
+ private void ThrowNoInvokeException()
+ {
+ // method is ReflectionOnly
+ Type declaringType = DeclaringType;
+ if ((declaringType == null && Module.Assembly.ReflectionOnly) || declaringType is ReflectionOnlyType)
+ {
+ throw new InvalidOperationException(SR.Arg_ReflectionOnlyInvoke);
+ }
+ // method is on a class that contains stack pointers
+ else if ((InvocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_CONTAINS_STACK_POINTERS) != 0)
+ {
+ throw new NotSupportedException();
+ }
+ // method is vararg
+ else if ((CallingConvention & CallingConventions.VarArgs) == CallingConventions.VarArgs)
+ {
+ throw new NotSupportedException();
+ }
+ // method is generic or on a generic class
+ else if (DeclaringType.ContainsGenericParameters || ContainsGenericParameters)
+ {
+ throw new InvalidOperationException(SR.Arg_UnboundGenParam);
+ }
+ // method is abstract class
+ else if (IsAbstract)
+ {
+ throw new MemberAccessException();
+ }
+ // ByRef return are not allowed in reflection
+ else if (ReturnType.IsByRef)
+ {
+ throw new NotSupportedException(SR.NotSupported_ByRefReturn);
+ }
+
+ throw new TargetException();
+ }
+
+ [DebuggerStepThroughAttribute]
+ [Diagnostics.DebuggerHidden]
+ [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
+ public override Object Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
+ {
+ object[] arguments = InvokeArgumentsCheck(obj, invokeAttr, binder, parameters, culture);
+
+ return UnsafeInvokeInternal(obj, parameters, arguments);
+ }
+
+ [DebuggerStepThroughAttribute]
+ [Diagnostics.DebuggerHidden]
+ internal object UnsafeInvoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
+ {
+ object[] arguments = InvokeArgumentsCheck(obj, invokeAttr, binder, parameters, culture);
+
+ return UnsafeInvokeInternal(obj, parameters, arguments);
+ }
+
+ [DebuggerStepThroughAttribute]
+ [Diagnostics.DebuggerHidden]
+ private object UnsafeInvokeInternal(Object obj, Object[] parameters, Object[] arguments)
+ {
+ if (arguments == null || arguments.Length == 0)
+ return RuntimeMethodHandle.InvokeMethod(obj, null, Signature, false);
+ else
+ {
+ Object retValue = RuntimeMethodHandle.InvokeMethod(obj, arguments, Signature, false);
+
+ // copy out. This should be made only if ByRef are present.
+ for (int index = 0; index < arguments.Length; index++)
+ parameters[index] = arguments[index];
+
+ return retValue;
+ }
+ }
+
+ [DebuggerStepThroughAttribute]
+ [Diagnostics.DebuggerHidden]
+ private object[] InvokeArgumentsCheck(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
+ {
+ Signature sig = Signature;
+
+ // get the signature
+ int formalCount = sig.Arguments.Length;
+ int actualCount = (parameters != null) ? parameters.Length : 0;
+
+ INVOCATION_FLAGS invocationFlags = InvocationFlags;
+
+ // INVOCATION_FLAGS_CONTAINS_STACK_POINTERS means that the struct (either the declaring type or the return type)
+ // contains pointers that point to the stack. This is either a ByRef or a TypedReference. These structs cannot
+ // be boxed and thus cannot be invoked through reflection which only deals with boxed value type objects.
+ if ((invocationFlags & (INVOCATION_FLAGS.INVOCATION_FLAGS_NO_INVOKE | INVOCATION_FLAGS.INVOCATION_FLAGS_CONTAINS_STACK_POINTERS)) != 0)
+ ThrowNoInvokeException();
+
+ // check basic method consistency. This call will throw if there are problems in the target/method relationship
+ CheckConsistency(obj);
+
+ if (formalCount != actualCount)
+ throw new TargetParameterCountException(SR.Arg_ParmCnt);
+
+ if (actualCount != 0)
+ return CheckArguments(parameters, binder, invokeAttr, culture, sig);
+ else
+ return null;
+ }
+
+ #endregion
+
+ #region MethodInfo Overrides
+ public override Type ReturnType
+ {
+ get { return Signature.ReturnType; }
+ }
+
+ public override ICustomAttributeProvider ReturnTypeCustomAttributes
+ {
+ get { return ReturnParameter; }
+ }
+
+ public override ParameterInfo ReturnParameter
+ {
+ get
+ {
+ Contract.Ensures(m_returnParameter != null);
+
+ FetchReturnParameter();
+ return m_returnParameter as ParameterInfo;
+ }
+ }
+
+ public override MethodInfo GetBaseDefinition()
+ {
+ if (!IsVirtual || IsStatic || m_declaringType == null || m_declaringType.IsInterface)
+ return this;
+
+ int slot = RuntimeMethodHandle.GetSlot(this);
+ RuntimeType declaringType = (RuntimeType)DeclaringType;
+ RuntimeType baseDeclaringType = declaringType;
+ RuntimeMethodHandleInternal baseMethodHandle = new RuntimeMethodHandleInternal();
+
+ do
+ {
+ int cVtblSlots = RuntimeTypeHandle.GetNumVirtuals(declaringType);
+
+ if (cVtblSlots <= slot)
+ break;
+
+ baseMethodHandle = RuntimeTypeHandle.GetMethodAt(declaringType, slot);
+ baseDeclaringType = declaringType;
+
+ declaringType = (RuntimeType)declaringType.BaseType;
+ } while (declaringType != null);
+
+ return (MethodInfo)RuntimeType.GetMethodBase(baseDeclaringType, baseMethodHandle);
+ }
+
+ public override Delegate CreateDelegate(Type delegateType)
+ {
+ StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+
+ // This API existed in v1/v1.1 and only expected to create closed
+ // instance delegates. Constrain the call to BindToMethodInfo to
+ // open delegates only for backwards compatibility. But we'll allow
+ // relaxed signature checking and open static delegates because
+ // there's no ambiguity there (the caller would have to explicitly
+ // pass us a static method or a method with a non-exact signature
+ // and the only change in behavior from v1.1 there is that we won't
+ // fail the call).
+ return CreateDelegateInternal(
+ delegateType,
+ null,
+ DelegateBindingFlags.OpenDelegateOnly | DelegateBindingFlags.RelaxedSignature,
+ ref stackMark);
+ }
+
+ public override Delegate CreateDelegate(Type delegateType, Object target)
+ {
+ StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+
+ // This API is new in Whidbey and allows the full range of delegate
+ // flexability (open or closed delegates binding to static or
+ // instance methods with relaxed signature checking). The delegate
+ // can also be closed over null. There's no ambiguity with all these
+ // options since the caller is providing us a specific MethodInfo.
+ return CreateDelegateInternal(
+ delegateType,
+ target,
+ DelegateBindingFlags.RelaxedSignature,
+ ref stackMark);
+ }
+
+ private Delegate CreateDelegateInternal(Type delegateType, Object firstArgument, DelegateBindingFlags bindingFlags, ref StackCrawlMark stackMark)
+ {
+ // Validate the parameters.
+ if (delegateType == null)
+ throw new ArgumentNullException(nameof(delegateType));
+ Contract.EndContractBlock();
+
+ RuntimeType rtType = delegateType as RuntimeType;
+ if (rtType == null)
+ throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(delegateType));
+
+ if (!rtType.IsDelegate())
+ throw new ArgumentException(SR.Arg_MustBeDelegate, nameof(delegateType));
+
+ Delegate d = Delegate.CreateDelegateInternal(rtType, this, firstArgument, bindingFlags, ref stackMark);
+ if (d == null)
+ {
+ throw new ArgumentException(SR.Arg_DlgtTargMeth);
+ }
+
+ return d;
+ }
+
+ #endregion
+
+ #region Generics
+ public override MethodInfo MakeGenericMethod(params Type[] methodInstantiation)
+ {
+ if (methodInstantiation == null)
+ throw new ArgumentNullException(nameof(methodInstantiation));
+ Contract.EndContractBlock();
+
+ RuntimeType[] methodInstantionRuntimeType = new RuntimeType[methodInstantiation.Length];
+
+ if (!IsGenericMethodDefinition)
+ throw new InvalidOperationException(
+ SR.Format(SR.Arg_NotGenericMethodDefinition, this));
+
+ for (int i = 0; i < methodInstantiation.Length; i++)
+ {
+ Type methodInstantiationElem = methodInstantiation[i];
+
+ if (methodInstantiationElem == null)
+ throw new ArgumentNullException();
+
+ RuntimeType rtMethodInstantiationElem = methodInstantiationElem as RuntimeType;
+
+ if (rtMethodInstantiationElem == null)
+ {
+ Type[] methodInstantiationCopy = new Type[methodInstantiation.Length];
+ for (int iCopy = 0; iCopy < methodInstantiation.Length; iCopy++)
+ methodInstantiationCopy[iCopy] = methodInstantiation[iCopy];
+ methodInstantiation = methodInstantiationCopy;
+ return System.Reflection.Emit.MethodBuilderInstantiation.MakeGenericMethod(this, methodInstantiation);
+ }
+
+ methodInstantionRuntimeType[i] = rtMethodInstantiationElem;
+ }
+
+ RuntimeType[] genericParameters = GetGenericArgumentsInternal();
+
+ RuntimeType.SanityCheckGenericArguments(methodInstantionRuntimeType, genericParameters);
+
+ MethodInfo ret = null;
+
+ try
+ {
+ ret = RuntimeType.GetMethodBase(ReflectedTypeInternal,
+ RuntimeMethodHandle.GetStubIfNeeded(new RuntimeMethodHandleInternal(m_handle), m_declaringType, methodInstantionRuntimeType)) as MethodInfo;
+ }
+ catch (VerificationException e)
+ {
+ RuntimeType.ValidateGenericArguments(this, methodInstantionRuntimeType, e);
+ throw;
+ }
+
+ return ret;
+ }
+
+ internal RuntimeType[] GetGenericArgumentsInternal()
+ {
+ return RuntimeMethodHandle.GetMethodInstantiationInternal(this);
+ }
+
+ public override Type[] GetGenericArguments()
+ {
+ Type[] types = RuntimeMethodHandle.GetMethodInstantiationPublic(this);
+
+ if (types == null)
+ {
+ types = Array.Empty<Type>();
+ }
+ return types;
+ }
+
+ public override MethodInfo GetGenericMethodDefinition()
+ {
+ if (!IsGenericMethod)
+ throw new InvalidOperationException();
+ Contract.EndContractBlock();
+
+ return RuntimeType.GetMethodBase(m_declaringType, RuntimeMethodHandle.StripMethodInstantiation(this)) as MethodInfo;
+ }
+
+ public override bool IsGenericMethod
+ {
+ get { return RuntimeMethodHandle.HasMethodInstantiation(this); }
+ }
+
+ public override bool IsGenericMethodDefinition
+ {
+ get { return RuntimeMethodHandle.IsGenericMethodDefinition(this); }
+ }
+
+ public override bool ContainsGenericParameters
+ {
+ get
+ {
+ if (DeclaringType != null && DeclaringType.ContainsGenericParameters)
+ return true;
+
+ if (!IsGenericMethod)
+ return false;
+
+ Type[] pis = GetGenericArguments();
+ for (int i = 0; i < pis.Length; i++)
+ {
+ if (pis[i].ContainsGenericParameters)
+ return true;
+ }
+
+ return false;
+ }
+ }
+ #endregion
+
+ #region ISerializable Implementation
+ public void GetObjectData(SerializationInfo info, StreamingContext context)
+ {
+ if (info == null)
+ throw new ArgumentNullException(nameof(info));
+ Contract.EndContractBlock();
+
+ if (m_reflectedTypeCache.IsGlobal)
+ throw new NotSupportedException(SR.NotSupported_GlobalMethodSerialization);
+
+ MemberInfoSerializationHolder.GetSerializationInfo(info, this);
+ }
+
+ internal string SerializationToString()
+ {
+ return ReturnType.FormatTypeName(true) + " " + FormatNameAndSig(true);
+ }
+ #endregion
+
+ #region Legacy Internal
+ internal static MethodBase InternalGetCurrentMethod(ref StackCrawlMark stackMark)
+ {
+ IRuntimeMethodInfo method = RuntimeMethodHandle.GetCurrentMethod(ref stackMark);
+
+ if (method == null)
+ return null;
+
+ return RuntimeType.GetMethodBase(method);
+ }
+ #endregion
+ }
+}