niko
461 lines
27 KiB
C#
461 lines
27 KiB
C#
using System;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.Reflection.Emit;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace System.Reflection
|
|
{
|
|
/// <summary>Provides information about methods and constructors. </summary>
|
|
// Token: 0x0200024C RID: 588
|
|
[ClassInterface(ClassInterfaceType.None)]
|
|
[ComVisible(true)]
|
|
[ComDefaultInterface(typeof(_MethodBase))]
|
|
[Serializable]
|
|
public abstract class MethodBase : MemberInfo, _MethodBase
|
|
{
|
|
/// <summary>Maps a set of names to a corresponding set of dispatch identifiers.</summary>
|
|
/// <param name="riid">Reserved for future use. Must be IID_NULL.</param>
|
|
/// <param name="rgszNames">Passed-in array of names to be mapped.</param>
|
|
/// <param name="cNames">Count of the names to be mapped.</param>
|
|
/// <param name="lcid">The locale context in which to interpret the names.</param>
|
|
/// <param name="rgDispId">Caller-allocated array which receives the IDs corresponding to the names.</param>
|
|
/// <exception cref="T:System.NotImplementedException">Late-bound access using the COM IDispatch interface is not supported.</exception>
|
|
// Token: 0x06001E50 RID: 7760 RVA: 0x00070E7C File Offset: 0x0006F07C
|
|
void _MethodBase.GetIDsOfNames([In] ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>Retrieves the type information for an object, which can then be used to get the type information for an interface.</summary>
|
|
/// <param name="iTInfo">The type information to return.</param>
|
|
/// <param name="lcid">The locale identifier for the type information.</param>
|
|
/// <param name="ppTInfo">Receives a pointer to the requested type information object.</param>
|
|
/// <exception cref="T:System.NotImplementedException">Late-bound access using the COM IDispatch interface is not supported.</exception>
|
|
// Token: 0x06001E51 RID: 7761 RVA: 0x00070E84 File Offset: 0x0006F084
|
|
void _MethodBase.GetTypeInfo(uint iTInfo, uint lcid, IntPtr ppTInfo)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>Retrieves the number of type information interfaces that an object provides (either 0 or 1).</summary>
|
|
/// <param name="pcTInfo">Points to a location that receives the number of type information interfaces provided by the object.</param>
|
|
/// <exception cref="T:System.NotImplementedException">Late-bound access using the COM IDispatch interface is not supported.</exception>
|
|
// Token: 0x06001E52 RID: 7762 RVA: 0x00070E8C File Offset: 0x0006F08C
|
|
void _MethodBase.GetTypeInfoCount(out uint pcTInfo)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>Provides access to properties and methods exposed by an object.</summary>
|
|
/// <param name="dispIdMember">Identifies the member.</param>
|
|
/// <param name="riid">Reserved for future use. Must be IID_NULL.</param>
|
|
/// <param name="lcid">The locale context in which to interpret arguments.</param>
|
|
/// <param name="wFlags">Flags describing the context of the call.</param>
|
|
/// <param name="pDispParams">Pointer to a structure containing an array of arguments, an array of argument DISPIDs for named arguments, and counts for the number of elements in the arrays.</param>
|
|
/// <param name="pVarResult">Pointer to the location where the result is to be stored.</param>
|
|
/// <param name="pExcepInfo">Pointer to a structure that contains exception information.</param>
|
|
/// <param name="puArgErr">The index of the first argument that has an error.</param>
|
|
/// <exception cref="T:System.NotImplementedException">Late-bound access using the COM IDispatch interface is not supported.</exception>
|
|
// Token: 0x06001E53 RID: 7763 RVA: 0x00070E94 File Offset: 0x0006F094
|
|
void _MethodBase.Invoke(uint dispIdMember, [In] ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>Returns a MethodBase object representing the currently executing method.</summary>
|
|
/// <returns>A MethodBase object representing the currently executing method.</returns>
|
|
/// <exception cref="T:System.Reflection.TargetException">This member was invoked with a late-binding mechanism.</exception>
|
|
// Token: 0x06001E54 RID: 7764
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
public static extern MethodBase GetCurrentMethod();
|
|
|
|
// Token: 0x06001E55 RID: 7765 RVA: 0x00070E9C File Offset: 0x0006F09C
|
|
internal static MethodBase GetMethodFromHandleNoGenericCheck(RuntimeMethodHandle handle)
|
|
{
|
|
return MethodBase.GetMethodFromIntPtr(handle.Value, IntPtr.Zero);
|
|
}
|
|
|
|
// Token: 0x06001E56 RID: 7766 RVA: 0x00070EB0 File Offset: 0x0006F0B0
|
|
private static MethodBase GetMethodFromIntPtr(IntPtr handle, IntPtr declaringType)
|
|
{
|
|
if (handle == IntPtr.Zero)
|
|
{
|
|
throw new ArgumentException("The handle is invalid.");
|
|
}
|
|
MethodBase methodFromHandleInternalType = MethodBase.GetMethodFromHandleInternalType(handle, declaringType);
|
|
if (methodFromHandleInternalType == null)
|
|
{
|
|
throw new ArgumentException("The handle is invalid.");
|
|
}
|
|
return methodFromHandleInternalType;
|
|
}
|
|
|
|
/// <summary>Gets method information by using the method's internal metadata representation (handle).</summary>
|
|
/// <returns>A MethodBase containing information about the method.</returns>
|
|
/// <param name="handle">The method's handle. </param>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="handle" /> is invalid.</exception>
|
|
// Token: 0x06001E57 RID: 7767 RVA: 0x00070EF4 File Offset: 0x0006F0F4
|
|
public static MethodBase GetMethodFromHandle(RuntimeMethodHandle handle)
|
|
{
|
|
MethodBase methodFromIntPtr = MethodBase.GetMethodFromIntPtr(handle.Value, IntPtr.Zero);
|
|
Type declaringType = methodFromIntPtr.DeclaringType;
|
|
if (declaringType.IsGenericType || declaringType.IsGenericTypeDefinition)
|
|
{
|
|
throw new ArgumentException("Cannot resolve method because it's declared in a generic class.");
|
|
}
|
|
return methodFromIntPtr;
|
|
}
|
|
|
|
// Token: 0x06001E58 RID: 7768
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
private static extern MethodBase GetMethodFromHandleInternalType(IntPtr method_handle, IntPtr type_handle);
|
|
|
|
/// <summary>Gets a <see cref="T:System.Reflection.MethodBase" /> object for the constructor or method represented by the specified handle, for the specified generic type.</summary>
|
|
/// <returns>A <see cref="T:System.Reflection.MethodBase" /> object representing the method or constructor specified by <paramref name="handle" />, in the generic type specified by <paramref name="declaringType" />.</returns>
|
|
/// <param name="handle">A handle to the internal metadata representation of a constructor or method.</param>
|
|
/// <param name="declaringType">A handle to the generic type that defines the constructor or method.</param>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="handle" /> is invalid.</exception>
|
|
// Token: 0x06001E59 RID: 7769 RVA: 0x00070F3C File Offset: 0x0006F13C
|
|
[ComVisible(false)]
|
|
public static MethodBase GetMethodFromHandle(RuntimeMethodHandle handle, RuntimeTypeHandle declaringType)
|
|
{
|
|
return MethodBase.GetMethodFromIntPtr(handle.Value, declaringType.Value);
|
|
}
|
|
|
|
/// <summary>When overridden in a derived class, returns the <see cref="T:System.Reflection.MethodImplAttributes" /> flags.</summary>
|
|
/// <returns>The MethodImplAttributes flags.</returns>
|
|
// Token: 0x06001E5A RID: 7770
|
|
public abstract MethodImplAttributes GetMethodImplementationFlags();
|
|
|
|
/// <summary>When overridden in a derived class, gets the parameters of the specified method or constructor.</summary>
|
|
/// <returns>An array of type ParameterInfo containing information that matches the signature of the method (or constructor) reflected by this MethodBase instance.</returns>
|
|
// Token: 0x06001E5B RID: 7771
|
|
public abstract ParameterInfo[] GetParameters();
|
|
|
|
// Token: 0x06001E5C RID: 7772 RVA: 0x00070F54 File Offset: 0x0006F154
|
|
internal virtual int GetParameterCount()
|
|
{
|
|
ParameterInfo[] parameters = this.GetParameters();
|
|
if (parameters == null)
|
|
{
|
|
return 0;
|
|
}
|
|
return parameters.Length;
|
|
}
|
|
|
|
/// <summary>Invokes the method or constructor represented by the current instance, using the specified parameters.</summary>
|
|
/// <returns>An object containing the return value of the invoked method, or null in the case of a constructor.</returns>
|
|
/// <param name="obj">The object on which to invoke the method or constructor. If a method is static, this argument is ignored. If a constructor is static, this argument must be null or an instance of the class that defines the constructor. </param>
|
|
/// <param name="parameters">An argument list for the invoked method or constructor. This is an array of objects with the same number, order, and type as the parameters of the method or constructor to be invoked. If there are no parameters, <paramref name="parameters" /> should be null.If the method or constructor represented by this instance takes a ref parameter (ByRef in Visual Basic), no special attribute is required for that parameter in order to invoke the method or constructor using this function. Any object in this array that is not explicitly initialized with a value will contain the default value for that object type. For reference-type elements, this value is null. For value-type elements, this value is 0, 0.0, or false, depending on the specific element type. </param>
|
|
/// <exception cref="T:System.Reflection.TargetException">The <paramref name="obj" /> parameter is null and the method is not static.-or- The method is not declared or inherited by the class of <paramref name="obj" />. -or-A static constructor is invoked, and <paramref name="obj" /> is neither null nor an instance of the class that declared the constructor.</exception>
|
|
/// <exception cref="T:System.ArgumentException">The elements of the <paramref name="parameters" /> array do not match the signature of the method or constructor reflected by this instance. </exception>
|
|
/// <exception cref="T:System.Reflection.TargetInvocationException">The invoked method or constructor throws an exception. </exception>
|
|
/// <exception cref="T:System.Reflection.TargetParameterCountException">The <paramref name="parameters" /> array does not have the correct number of arguments. </exception>
|
|
/// <exception cref="T:System.MethodAccessException">The caller does not have permission to execute the constructor. </exception>
|
|
/// <exception cref="T:System.InvalidOperationException">The type that declares the method is an open generic type. That is, the <see cref="P:System.Type.ContainsGenericParameters" /> property returns true for the declaring type.</exception>
|
|
/// <exception cref="T:System.NotSupportedException">The current <see cref="T:System.Reflection.MethodBase" /> is a <see cref="T:System.Reflection.Emit.MethodBuilder" />. </exception>
|
|
// Token: 0x06001E5D RID: 7773 RVA: 0x00070F74 File Offset: 0x0006F174
|
|
[DebuggerHidden]
|
|
[DebuggerStepThrough]
|
|
public object Invoke(object obj, object[] parameters)
|
|
{
|
|
return this.Invoke(obj, BindingFlags.Default, null, parameters, null);
|
|
}
|
|
|
|
/// <summary>When overridden in a derived class, invokes the reflected method or constructor with the given parameters.</summary>
|
|
/// <returns>An Object containing the return value of the invoked method, or null in the case of a constructor, or null if the method's return type is void. Before calling the method or constructor, Invoke checks to see if the user has access permission and verify that the parameters are valid.</returns>
|
|
/// <param name="obj">The object on which to invoke the method or constructor. If a method is static, this argument is ignored. If a constructor is static, this argument must be null or an instance of the class that defines the constructor.</param>
|
|
/// <param name="invokeAttr">A bitmask that is a combination of 0 or more bit flags from <see cref="T:System.Reflection.BindingFlags" />. If <paramref name="binder" /> is null, this parameter is assigned the value <see cref="F:System.Reflection.BindingFlags.Default" />; thus, whatever you pass in is ignored. </param>
|
|
/// <param name="binder">An object that enables the binding, coercion of argument types, invocation of members, and retrieval of MemberInfo objects via reflection. If <paramref name="binder" /> is null, the default binder is used. </param>
|
|
/// <param name="parameters">An argument list for the invoked method or constructor. This is an array of objects with the same number, order, and type as the parameters of the method or constructor to be invoked. If there are no parameters, this should be null.If the method or constructor represented by this instance takes a ByRef parameter, there is no special attribute required for that parameter in order to invoke the method or constructor using this function. Any object in this array that is not explicitly initialized with a value will contain the default value for that object type. For reference-type elements, this value is null. For value-type elements, this value is 0, 0.0, or false, depending on the specific element type. </param>
|
|
/// <param name="culture">An instance of CultureInfo used to govern the coercion of types. If this is null, the CultureInfo for the current thread is used. (This is necessary to convert a String that represents 1000 to a Double value, for example, since 1000 is represented differently by different cultures.) </param>
|
|
/// <exception cref="T:System.Reflection.TargetException">The <paramref name="obj" /> parameter is null and the method is not static.-or- The method is not declared or inherited by the class of <paramref name="obj" />. -or-A static constructor is invoked, and <paramref name="obj" /> is neither null nor an instance of the class that declared the constructor.</exception>
|
|
/// <exception cref="T:System.ArgumentException">The type of the <paramref name="parameters" /> parameter does not match the signature of the method or constructor reflected by this instance. </exception>
|
|
/// <exception cref="T:System.Reflection.TargetParameterCountException">The <paramref name="parameters" /> array does not have the correct number of arguments. </exception>
|
|
/// <exception cref="T:System.Reflection.TargetInvocationException">The invoked method or constructor throws an exception. </exception>
|
|
/// <exception cref="T:System.MethodAccessException">The caller does not have permission to execute the constructor. </exception>
|
|
/// <exception cref="T:System.InvalidOperationException">The type that declares the method is an open generic type. That is, the <see cref="P:System.Type.ContainsGenericParameters" /> property returns true for the declaring type.</exception>
|
|
// Token: 0x06001E5E RID: 7774
|
|
public abstract object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture);
|
|
|
|
/// <summary>Gets a handle to the internal metadata representation of a method.</summary>
|
|
/// <returns>A <see cref="T:System.RuntimeMethodHandle" /> object.</returns>
|
|
// Token: 0x17000588 RID: 1416
|
|
// (get) Token: 0x06001E5F RID: 7775
|
|
public abstract RuntimeMethodHandle MethodHandle { get; }
|
|
|
|
/// <summary>Gets the attributes associated with this method.</summary>
|
|
/// <returns>One of the <see cref="T:System.Reflection.MethodAttributes" /> values.</returns>
|
|
// Token: 0x17000589 RID: 1417
|
|
// (get) Token: 0x06001E60 RID: 7776
|
|
public abstract MethodAttributes Attributes { get; }
|
|
|
|
/// <summary>Gets a value indicating the calling conventions for this method.</summary>
|
|
/// <returns>The <see cref="T:System.Reflection.CallingConventions" /> for this method.</returns>
|
|
// Token: 0x1700058A RID: 1418
|
|
// (get) Token: 0x06001E61 RID: 7777 RVA: 0x00070F84 File Offset: 0x0006F184
|
|
public virtual CallingConventions CallingConvention
|
|
{
|
|
get
|
|
{
|
|
return CallingConventions.Standard;
|
|
}
|
|
}
|
|
|
|
/// <summary>Gets a value indicating whether this is a public method.</summary>
|
|
/// <returns>true if this method is public; otherwise, false.</returns>
|
|
// Token: 0x1700058B RID: 1419
|
|
// (get) Token: 0x06001E62 RID: 7778 RVA: 0x00070F88 File Offset: 0x0006F188
|
|
public bool IsPublic
|
|
{
|
|
get
|
|
{
|
|
return (this.Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Public;
|
|
}
|
|
}
|
|
|
|
/// <summary>Gets a value indicating whether this member is private.</summary>
|
|
/// <returns>true if access to this method is restricted to other members of the class itself; otherwise, false.</returns>
|
|
// Token: 0x1700058C RID: 1420
|
|
// (get) Token: 0x06001E63 RID: 7779 RVA: 0x00070F98 File Offset: 0x0006F198
|
|
public bool IsPrivate
|
|
{
|
|
get
|
|
{
|
|
return (this.Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Private;
|
|
}
|
|
}
|
|
|
|
/// <summary>Gets a value indicating whether the visibility of this method or constructor is described by <see cref="F:System.Reflection.MethodAttributes.Family" />; that is, the method or constructor is visible only within its class and derived classes.</summary>
|
|
/// <returns>true if access to this method or constructor is exactly described by <see cref="F:System.Reflection.MethodAttributes.Family" />; otherwise, false.</returns>
|
|
// Token: 0x1700058D RID: 1421
|
|
// (get) Token: 0x06001E64 RID: 7780 RVA: 0x00070FA8 File Offset: 0x0006F1A8
|
|
public bool IsFamily
|
|
{
|
|
get
|
|
{
|
|
return (this.Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Family;
|
|
}
|
|
}
|
|
|
|
/// <summary>Gets a value indicating whether the potential visibility of this method or constructor is described by <see cref="F:System.Reflection.MethodAttributes.Assembly" />; that is, the method or constructor is visible at most to other types in the same assembly, and is not visible to derived types outside the assembly.</summary>
|
|
/// <returns>true if the visibility of this method or constructor is exactly described by <see cref="F:System.Reflection.MethodAttributes.Assembly" />; otherwise, false.</returns>
|
|
// Token: 0x1700058E RID: 1422
|
|
// (get) Token: 0x06001E65 RID: 7781 RVA: 0x00070FB8 File Offset: 0x0006F1B8
|
|
public bool IsAssembly
|
|
{
|
|
get
|
|
{
|
|
return (this.Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Assembly;
|
|
}
|
|
}
|
|
|
|
/// <summary>Gets a value indicating whether the visibility of this method or constructor is described by <see cref="F:System.Reflection.MethodAttributes.FamANDAssem" />; that is, the method or constructor can be called by derived classes, but only if they are in the same assembly.</summary>
|
|
/// <returns>true if access to this method or constructor is exactly described by <see cref="F:System.Reflection.MethodAttributes.FamANDAssem" />; otherwise, false.</returns>
|
|
// Token: 0x1700058F RID: 1423
|
|
// (get) Token: 0x06001E66 RID: 7782 RVA: 0x00070FC8 File Offset: 0x0006F1C8
|
|
public bool IsFamilyAndAssembly
|
|
{
|
|
get
|
|
{
|
|
return (this.Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.FamANDAssem;
|
|
}
|
|
}
|
|
|
|
/// <summary>Gets a value indicating whether the potential visibility of this method or constructor is described by <see cref="F:System.Reflection.MethodAttributes.FamORAssem" />; that is, the method or constructor can be called by derived classes wherever they are, and by classes in the same assembly.</summary>
|
|
/// <returns>true if access to this method or constructor is exactly described by <see cref="F:System.Reflection.MethodAttributes.FamORAssem" />; otherwise, false.</returns>
|
|
// Token: 0x17000590 RID: 1424
|
|
// (get) Token: 0x06001E67 RID: 7783 RVA: 0x00070FD8 File Offset: 0x0006F1D8
|
|
public bool IsFamilyOrAssembly
|
|
{
|
|
get
|
|
{
|
|
return (this.Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.FamORAssem;
|
|
}
|
|
}
|
|
|
|
/// <summary>Gets a value indicating whether the method is static.</summary>
|
|
/// <returns>true if this method is static; otherwise, false.</returns>
|
|
// Token: 0x17000591 RID: 1425
|
|
// (get) Token: 0x06001E68 RID: 7784 RVA: 0x00070FE8 File Offset: 0x0006F1E8
|
|
public bool IsStatic
|
|
{
|
|
get
|
|
{
|
|
return (this.Attributes & MethodAttributes.Static) != MethodAttributes.PrivateScope;
|
|
}
|
|
}
|
|
|
|
/// <summary>Gets a value indicating whether this method is final.</summary>
|
|
/// <returns>true if this method is final; otherwise, false.</returns>
|
|
// Token: 0x17000592 RID: 1426
|
|
// (get) Token: 0x06001E69 RID: 7785 RVA: 0x00070FFC File Offset: 0x0006F1FC
|
|
public bool IsFinal
|
|
{
|
|
get
|
|
{
|
|
return (this.Attributes & MethodAttributes.Final) != MethodAttributes.PrivateScope;
|
|
}
|
|
}
|
|
|
|
/// <summary>Gets a value indicating whether the method is virtual.</summary>
|
|
/// <returns>true if this method is virtual; otherwise, false.</returns>
|
|
// Token: 0x17000593 RID: 1427
|
|
// (get) Token: 0x06001E6A RID: 7786 RVA: 0x00071010 File Offset: 0x0006F210
|
|
public bool IsVirtual
|
|
{
|
|
get
|
|
{
|
|
return (this.Attributes & MethodAttributes.Virtual) != MethodAttributes.PrivateScope;
|
|
}
|
|
}
|
|
|
|
/// <summary>Gets a value indicating whether only a member of the same kind with exactly the same signature is hidden in the derived class.</summary>
|
|
/// <returns>true if the member is hidden by signature; otherwise, false.</returns>
|
|
// Token: 0x17000594 RID: 1428
|
|
// (get) Token: 0x06001E6B RID: 7787 RVA: 0x00071024 File Offset: 0x0006F224
|
|
public bool IsHideBySig
|
|
{
|
|
get
|
|
{
|
|
return (this.Attributes & MethodAttributes.HideBySig) != MethodAttributes.PrivateScope;
|
|
}
|
|
}
|
|
|
|
/// <summary>Gets a value indicating whether the method is abstract.</summary>
|
|
/// <returns>true if the method is abstract; otherwise, false.</returns>
|
|
// Token: 0x17000595 RID: 1429
|
|
// (get) Token: 0x06001E6C RID: 7788 RVA: 0x00071038 File Offset: 0x0006F238
|
|
public bool IsAbstract
|
|
{
|
|
get
|
|
{
|
|
return (this.Attributes & MethodAttributes.Abstract) != MethodAttributes.PrivateScope;
|
|
}
|
|
}
|
|
|
|
/// <summary>Gets a value indicating whether this method has a special name.</summary>
|
|
/// <returns>true if this method has a special name; otherwise, false.</returns>
|
|
// Token: 0x17000596 RID: 1430
|
|
// (get) Token: 0x06001E6D RID: 7789 RVA: 0x0007104C File Offset: 0x0006F24C
|
|
public bool IsSpecialName
|
|
{
|
|
get
|
|
{
|
|
int attributes = (int)this.Attributes;
|
|
return (attributes & 2048) != 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>Gets a value indicating whether the method is a constructor.</summary>
|
|
/// <returns>true if this method is a constructor represented by a <see cref="T:System.Reflection.ConstructorInfo" /> object (see note in Remarks about <see cref="T:System.Reflection.Emit.ConstructorBuilder" /> objects); otherwise, false.</returns>
|
|
// Token: 0x17000597 RID: 1431
|
|
// (get) Token: 0x06001E6E RID: 7790 RVA: 0x00071070 File Offset: 0x0006F270
|
|
[ComVisible(true)]
|
|
public bool IsConstructor
|
|
{
|
|
get
|
|
{
|
|
int attributes = (int)this.Attributes;
|
|
return (attributes & 4096) != 0 && this.Name == ".ctor";
|
|
}
|
|
}
|
|
|
|
// Token: 0x06001E6F RID: 7791 RVA: 0x000710A4 File Offset: 0x0006F2A4
|
|
internal virtual int get_next_table_index(object obj, int table, bool inc)
|
|
{
|
|
if (this is MethodBuilder)
|
|
{
|
|
MethodBuilder methodBuilder = (MethodBuilder)this;
|
|
return methodBuilder.get_next_table_index(obj, table, inc);
|
|
}
|
|
if (this is ConstructorBuilder)
|
|
{
|
|
ConstructorBuilder constructorBuilder = (ConstructorBuilder)this;
|
|
return constructorBuilder.get_next_table_index(obj, table, inc);
|
|
}
|
|
throw new Exception("Method is not a builder method");
|
|
}
|
|
|
|
/// <summary>Returns an array of <see cref="T:System.Type" /> objects that represent the type arguments of a generic method or the type parameters of a generic method definition.</summary>
|
|
/// <returns>An array of <see cref="T:System.Type" /> objects that represent the type arguments of a generic method or the type parameters of a generic method definition. Returns an empty array if the current method is not a generic method.</returns>
|
|
/// <exception cref="T:System.NotSupportedException">The current object is a <see cref="T:System.Reflection.ConstructorInfo" />. Generic constructors are not supported in the .NET Framework version 2.0. This exception is the default behavior if this method is not overridden in a derived class.</exception>
|
|
// Token: 0x06001E70 RID: 7792 RVA: 0x000710F4 File Offset: 0x0006F2F4
|
|
[ComVisible(true)]
|
|
public virtual Type[] GetGenericArguments()
|
|
{
|
|
throw new NotSupportedException();
|
|
}
|
|
|
|
/// <summary>Gets a value indicating whether the generic method contains unassigned generic type parameters.</summary>
|
|
/// <returns>true if the current <see cref="T:System.Reflection.MethodBase" /> object represents a generic method that contains unassigned generic type parameters; otherwise, false.</returns>
|
|
// Token: 0x17000598 RID: 1432
|
|
// (get) Token: 0x06001E71 RID: 7793 RVA: 0x000710FC File Offset: 0x0006F2FC
|
|
public virtual bool ContainsGenericParameters
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>Gets a value indicating whether the method is a generic method definition.</summary>
|
|
/// <returns>true if the current <see cref="T:System.Reflection.MethodBase" /> object represents the definition of a generic method; otherwise, false.</returns>
|
|
// Token: 0x17000599 RID: 1433
|
|
// (get) Token: 0x06001E72 RID: 7794 RVA: 0x00071100 File Offset: 0x0006F300
|
|
public virtual bool IsGenericMethodDefinition
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>Gets a value indicating whether the method is generic.</summary>
|
|
/// <returns>true if the current <see cref="T:System.Reflection.MethodBase" /> represents a generic method; otherwise, false.</returns>
|
|
// Token: 0x1700059A RID: 1434
|
|
// (get) Token: 0x06001E73 RID: 7795 RVA: 0x00071104 File Offset: 0x0006F304
|
|
public virtual bool IsGenericMethod
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06001E74 RID: 7796
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
|
internal static extern MethodBody GetMethodBodyInternal(IntPtr handle);
|
|
|
|
// Token: 0x06001E75 RID: 7797 RVA: 0x00071108 File Offset: 0x0006F308
|
|
internal static MethodBody GetMethodBody(IntPtr handle)
|
|
{
|
|
return MethodBase.GetMethodBodyInternal(handle);
|
|
}
|
|
|
|
/// <summary>When overridden in a derived class, gets a <see cref="T:System.Reflection.MethodBody" /> object that provides access to the MSIL stream, local variables, and exceptions for the current method.</summary>
|
|
/// <returns>A <see cref="T:System.Reflection.MethodBody" /> object that provides access to the MSIL stream, local variables, and exceptions for the current method.</returns>
|
|
/// <exception cref="T:System.InvalidOperationException">This method is invalid unless overridden in a derived class.</exception>
|
|
/// <PermissionSet>
|
|
/// <IPermission class="System.Security.Permissions.ReflectionPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="MemberAccess" />
|
|
/// </PermissionSet>
|
|
// Token: 0x06001E76 RID: 7798 RVA: 0x00071110 File Offset: 0x0006F310
|
|
public virtual MethodBody GetMethodBody()
|
|
{
|
|
throw new NotSupportedException();
|
|
}
|
|
|
|
/// <summary>Provides COM objects with version-independent access to the <see cref="M:System.Runtime.InteropServices._MethodBase.GetType" /> method.</summary>
|
|
/// <returns>See <see cref="M:System.Runtime.InteropServices._MethodBase.GetType" />.</returns>
|
|
// Token: 0x06001E77 RID: 7799 RVA: 0x00071118 File Offset: 0x0006F318
|
|
virtual Type System.Runtime.InteropServices._MethodBase.GetType()
|
|
{
|
|
return base.GetType();
|
|
}
|
|
}
|
|
}
|