Reflection mscorlib [00 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00 ] 1.0.5000.0 2.0.0.0 4.0.0.0 All public static members of this type are safe for multithreaded operations. No instance members are guaranteed to be thread safe. System.Reflection.MemberInfo System.Runtime.InteropServices._MethodBase System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None) System.Runtime.InteropServices.ComDefaultInterface(typeof(System.Runtime.InteropServices._MethodBase)) System.Runtime.InteropServices.ComVisible(true)

MethodBase is the base class of and .

Provides information about methods and constructors.

- Constructor
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  To be added.

  Initializes a new instance of the class.

  0
- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Reflection.MethodAttributes

  A value that signifies the attributes of the method reflected by the current instance.

  The following example demonstrates using this property to obtain the attributes of three methods.

  `using System; using System.Reflection; abstract class MyBaseClass { abstract public void MyPublicInstanceMethod(); } class MyDerivedClass : MyBaseClass { public override void MyPublicInstanceMethod() {} private static void MyPrivateStaticMethod() {} } class MethodAttributesExample { static void PrintMethodAttributes(Type t) { string str; MethodInfo[] miAry = t.GetMethods( BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly ); foreach (MethodInfo mi in miAry) { Console.WriteLine("Method {0} is: ", mi.Name); str = ((mi.Attributes & MethodAttributes.Static) != 0) ? "Static" : "Instance"; Console.Write(str + " "); str = ((mi.Attributes & MethodAttributes.Public) != 0) ? "Public" : "Not-Public"; Console.Write(str + " "); str = ((mi.Attributes & MethodAttributes.HideBySig) != 0) ? "HideBySig" : "Hide-by-name"; Console.Write(str + " "); str = ((mi.Attributes & MethodAttributes.Abstract) != 0) ? "Abstract" : String.Empty; Console.WriteLine(str); } } public static void Main() { PrintMethodAttributes(typeof(MyBaseClass)); PrintMethodAttributes(typeof(MyDerivedClass)); } }`

  The output is

  Method MyPublicInstanceMethod is:

  Instance Public HideBySig Abstract

  Method MyPublicInstanceMethod is:

  Instance Public HideBySig

  Method MyPrivateStaticMethod is:

  Static Not-Public HideBySig

  All members have a set of attributes, which are defined in relation to the specific type of member.

  To get the , first get the type. From the type, get the method. From the method, get the .

  Gets the attributes associated with this method.

  0
- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Reflection.CallingConventions To be added. To be added.

  Gets a value indicating the calling conventions for this method.

- Property
  2.0.0.0
  4.0.0.0
  System.Boolean

  if the current method contains unassigned generic type parameters; otherwise .

  A generic method can be invoked only if there are no generic type definitions or open constructed types in the type arguments of the method itself or in any enclosing types. Because types can be arbitrarily complex, making this recursive determination is difficult. For convenience, and to reduce the chance of error, the property provides a standard way to distinguish between closed constructed methods, which can be invoked, and open constructed methods, which cannot. If the property returns true, the method cannot be invoked.

  The property searches recursively for type parameters. For example, it returns true for any method in an open type A<T> (A(Of T) in Visual Basic), even though the method itself is not generic. Contrast this with the behavior of the property, which returns false for such a method.

  Similarly, the property parameter returns true for any constructor in an open type, even though constructors cannot have type parameters of their own.

  For a list of the invariant conditions for terms specific to generic methods, see the property. For a list of the invariant conditions for other terms used in generic reflection, see the property.

  Gets a value indicating whether the generic method contains unassigned generic type parameters.

- Method
  4.0.0.0
  System.Boolean `` To be added.

  Returns a value that indicates whether this instance is equal to a specified object.

  true if equals the type and value of this instance; otherwise, false.

  An object to compare with this instance, or null.
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Reflection.MethodBase

  If the currently executing method is defined on a generic type, the that is returned by is obtained from the generic type definition (that is, returns true). Therefore, it does not reflect the type arguments that were used when the method was called. For example, if a method M() is defined on a generic type C<T> (C(Of T) in Visual Basic), and is called from C<string>.M(), then returns C<T>.M() (C(Of T).M() in Visual Basic).

  If the currently executing method is a generic method, returns the generic method definition. If the generic method is defined on a generic type, the is obtained from the generic type definition.

  Returns a MethodBase object representing the currently executing method.

  A MethodBase object representing the currently executing method.

- Method
  2.0.0.0
  4.0.0.0
  System.Runtime.InteropServices.ComVisible(true)
  System.Type[]

  Default behavior when not overridden in a derived class.

  The elements of the returned array are in the order in which they appear in the list of type parameters for the generic method.

  If the current method is a closed constructed method (that is, the property returns false), the array returned by the method contains the types that have been assigned to the generic type parameters of the generic method definition.

  If the current method is a generic method definition, the array contains the type parameters.

  If the current method is an open constructed method (that is, the property returns true) in which specific types have been assigned to some type parameters and type parameters of enclosing generic types have been assigned to other type parameters, the array contains both types and type parameters. Use the property to tell them apart. For a demonstration of this scenario, see the code example provided for the property.

  Generic constructors are not supported in the .NET Framework version 2.0. This property throws if not overridden in a derived class, so an exception is thrown if the current instance is of type .

  For a list of the invariant conditions for terms specific to generic methods, see the property. For a list of the invariant conditions for other terms used in generic reflection, see the property.

  Returns an array of objects that represent the type arguments of a generic method or the type parameters of a generic method definition.

  An array of 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.

- Method
  4.0.0.0
  System.Int32 To be added.

  Returns the hash code for this instance.

  A 32-bit signed integer hash code.

- Method
  2.0.0.0
  4.0.0.0
  System.Reflection.MethodBody

  You do not have to override the in order to use it. You can call the method on and objects, because the method is overridden in the runtime versions of these classes. For example, the runtime version of the class derives from the class, which in turn derives from the class.

  When overridden in a derived class, gets a object that provides access to the MSIL stream, local variables, and exceptions for the current method.

  A object that provides access to the MSIL stream, local variables, and exceptions for the current method.

- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Reflection.MethodBase ``

  Handles are valid only in the application domain in which they were obtained.

  Gets method information by using the method's internal metadata representation (handle).

  A MethodBase containing information about the method.

  The method's handle. 1 RuntimeInfrastructure
- Method
  2.0.0.0
  4.0.0.0
  System.Runtime.InteropServices.ComVisible(false)
  System.Reflection.MethodBase `` ``

  Handles are valid only in the application domain in which they were obtained.

  A structure for a constructor or method of a generic type can represent different objects, depending on the types specified for the type parameters of the generic type. For example, if class G<T> (class G(Of T) in Visual Basic, generic <T> ref class G in C++) has a method that returns type T, the object for that method in a constructed class such as G<int> is different from the object for that method in the generic type definition.

  Gets a object for the constructor or method represented by the specified handle, for the specified generic type.

  A object representing the method or constructor specified by , in the generic type specified by .

  A handle to the internal metadata representation of a constructor or method. A handle to the generic type that defines the constructor or method.
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Reflection.MethodImplAttributes To be added.

  When overridden in a derived class, returns the flags.

  The MethodImplAttributes flags.

- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Reflection.ParameterInfo[]

  As described above.

  When overridden in a derived class, gets the parameters of the specified method or constructor.

  An array of type ParameterInfo containing information that matches the signature of the method (or constructor) reflected by this MethodBase instance.

  0
- Method
  System.Type To be added. To be added. To be added. 1.0.5000.0
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Diagnostics.DebuggerStepThrough
  System.Object `` `` The types of the elements of do not match the types of the parameters accepted by the constructor or method reflected by the current instance, under the constraints of the default binder. The constructor or method reflected by the current instance is non-static and is , or is of a type that does not implement the member reflected by the current instance. The constructor or method reflected by the current instance threw an exception. .Length does not equal the number of parameters required by the contract of the member reflected by the current instance. Requires permission to invoke non-public members of loaded assemblies. See . The caller does not have permission to execute the method or constructor. The type that declares the method is an open generic type. That is, returns for the declaring type. 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, should be null.

  This is a convenience method that calls the method overload, passing for and null for and .

  If the invoked method throws an exception, the method returns the exception.

  To invoke a static method using its object, pass null for .

  If this method overload is used to invoke an instance constructor, the object supplied for is reinitialized; that is, all instance initializers are executed. The return value is null. If a class constructor is invoked, the class is reinitialized; that is, all class initializers are executed. The return value is null.

  Starting with the net_v20sp1_long, this method can be used to access non-public members if the caller has been granted with the flag and if the grant set of the non-public members is restricted to the caller’s grant set, or a subset thereof. (See Security Considerations for Reflection.)

  To use this functionality, your application should target the net_v35_long or later.

  If a parameter of the current method is a value type, and the corresponding argument in is null, the runtime passes a zero-initialized instance of the value type.

  Invokes the method or constructor represented by the current instance, using the specified parameters.

  An object containing the return value of the invoked method, or null in the case of a constructor.

  Elements of the array that represent parameters declared with the ref or out keyword may also be modified.

  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. 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, should be null. 0
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Object `` `` `` `` `` The types of the elements of do not match the types of the parameters accepted by the constructor or method reflected by the current instance, under the constraints of the default binder. The constructor or method reflected by the current instance is non-static, and is or is of a type that does not implement the member reflected by the current instance. The method reflected by the current instance threw an exception. .Length does not equal the number of parameters required by the contract of the constructor or method reflected by the current instance. Requires permission to invoke non-public members of loaded assemblies. See . The caller does not have permission to execute the method or constructor. The type that declares the method is an open generic type. That is, returns for the declaring type. A bitmask that is a combination of 0 or more bit flags from . If is null, this parameter is assigned the value ; thus, whatever you pass in is ignored. An object that enables the binding, coercion of argument types, invocation of members, and retrieval of MemberInfo objects via reflection. If is null, the default binder is used. 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. 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.)

  Dynamically invokes the method reflected by this instance on , and passes along the specified parameters. If the method is static, the parameter is ignored. For non-static methods, should be an instance of a class that inherits or declares the method and must be the same type as this class. If the method has no parameters, the value of should be null. Otherwise, the number, type, and order of elements in should be identical to the number, type, and order of parameters for the method reflected by this instance.

  You may not omit optional parameters in calls to Invoke. To invoke a method omitting optional parameters, you should call Type.InvokeMember instead.

  If this method overload is used to invoke an instance constructor, the object supplied for is reinitialized; that is, all instance initializers are executed. The return value is null. If a class constructor is invoked, the class is reinitialized; that is, all class initializers are executed. The return value is null.

  For pass-by-value primitive parameters, normal widening is performed (Int16 -> Int32, for example). For pass-by-value reference parameters, normal reference widening is allowed (derived class to base class, and base class to interface type). However, for pass-by-reference primitive parameters, the types must match exactly. For pass-by-reference reference parameters, the normal widening still applies.

  For example, if the method reflected by this instance is declared as public boolean Compare(String a, String b), then should be an array of Objects with length 2 such that parameters[0] = new Object("SomeString1") and parameters[1] = new Object("SomeString2").

  If a parameter of the current method is a value type, and the corresponding argument in is null, the runtime passes a zero-initialized instance of the value type.

  Reflection uses dynamic method lookup when invoking virtual methods. For example, suppose that class B inherits from class A and both implement a virtual method named M. Now suppose that you have a MethodInfo object that represents M on class A. If you use the Invoke method to invoke M on an object of type B, then reflection will use the implementation given by class B. Even if the object of type B is cast to A, the implementation given by class B is used (see code sample below).

  On the other hand, if the method is non-virtual, then reflection will use the implementation given by the type from which the MethodInfo was obtained, regardless of the type of the object passed as the target.

  Access restrictions are ignored for fully trusted code. That is, private constructors, methods, fields, and properties can be accessed and invoked via reflection whenever the code is fully trusted.

  If the invoked method throws an exception, TargetInvocationException.GetException returns the exception. This implementation throws a NotSupportedException.

  Starting with the net_v20sp1_long, this method can be used to access non-public members if the caller has been granted with the flag and if the grant set of the non-public members is restricted to the caller’s grant set, or a subset thereof. (See Security Considerations for Reflection.)

  To use this functionality, your application should target the net_v35_long or later.

  When overridden in a derived class, invokes the reflected method or constructor with the given parameters.

  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 verifies that the parameters are valid.

  Elements of the array that represent parameters declared with the ref or out keyword may also be modified.

  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. A bitmask that is a combination of 0 or more bit flags from . If is null, this parameter is assigned the value ; thus, whatever you pass in is ignored. An object that enables the binding, coercion of argument types, invocation of members, and retrieval of MemberInfo objects via reflection. If is null, the default binder is used. 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. 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.) 0
- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Boolean To be added.

  An abstract member is declared on a base class and has no implementation supplied.

  To get the , first get the type. From the type, get the method. From the method, get the MethodBase. If the MethodBase or constructor is other than public, it is protected and cannot be readily accessed. To access a non-public method, set the mask to NonPublic in GetMethod.

  Gets a value indicating whether the method is abstract.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Boolean To be added.

  The actual visibility of a method is limited by the visibility of its type. The property might be true for a method, but if it is a method of a private nested type then the method is not visible outside the containing type.

  The visibility of a method or constructor is exactly described by if the only visibility modifier is internal (Friend in Visual Basic). This property is false for methods that are protected internal in C# (Protected Friend in Visual Basic, protected public in C++); use the property to identify such methods.

  Gets a value indicating whether the potential visibility of this method or constructor is described by ; 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.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Runtime.InteropServices.ComVisible(true)
  System.Boolean To be added.

  The property returns false for a object in a dynamic type, unless the flag was included in the parameter when the constructor was defined. Omitting the flag does not affect the correctness of the emitted constructor.

  Gets a value indicating whether the method is a constructor.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Boolean To be added.

  The visibility of a method or constructor is exactly described by if the only visibility modifier is protected. This property is false for methods that are protected internal in C# (Protected Friend in Visual Basic, protected public in C++); use the property to identify such methods.

  Gets a value indicating whether the visibility of this method or constructor is described by ; that is, the method or constructor is visible only within its class and derived classes.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Boolean To be added.

  The visibility of a method or constructor is exactly described by if the visibility modifier is protected private in C++. Methods with this visibility cannot be defined in Visual Basic or C#.

  Gets a value indicating whether the visibility of this method or constructor is described by ; that is, the method or constructor can be called by derived classes, but only if they are in the same assembly.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Boolean To be added.

  If a type member has visibility, it can be called from any member in a derived class or any member in the same assembly, but not from any other type.

  The actual visibility of a method is limited by the visibility of its type. The property might be true for a method, but if it is a method of a private nested type then the method is not visible outside the containing type.

  The visibility of a method or constructor is exactly described by if the visibility modifier is protected internal in C# (Protected Friend in Visual Basic, protected public in C++).

  Gets a value indicating whether the potential visibility of this method or constructor is described by ; that is, the method or constructor can be called by derived classes wherever they are, and by classes in the same assembly.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Boolean To be added.

  To determine if a method is overridable, it is not sufficient to check that is true. For a method to be overridable, IsVirtual must be true and IsFinal must be false. For example, a method might be non-virtual, but it implements an interface method. The common language runtime requires that all methods that implement interface members must be marked as virtual; therefore, the compiler marks the method virtual final. So there are cases where a method is marked as virtual but is still not overridable.

  To establish with certainty whether a method is overridable, use code such as this:

  if (MethodInfo.IsVirtual && !MethodInfo.IsFinal)

  If IsVirtual is false or IsFinal is true, then the method cannot be overridden.

  Gets a value indicating whether this method is final.

- Property
  2.0.0.0
  4.0.0.0
  System.Boolean if the current object is a generic method; otherwise .

  Use the property to determine whether the current object represents a generic method. Use the property to determine whether the current object represents an open constructed method or a closed constructed method.

  Generics are not supported by default; this property returns false if not overridden in a derived class. Generic constructors are not supported in the .NET Framework version 2.0, so this property returns false if the current instance is of type .

  For a list of the invariant conditions for terms specific to generic methods, see the property. For a list of the invariant conditions for other terms used in generic reflection, see the property.

  Gets a value indicating whether the method is generic.

- Property
  2.0.0.0
  4.0.0.0
  System.Boolean if the current object represents the definition of a generic method; otherwise .

  If the current represents a generic method definition, then:

  The property is true.

  For each object in the array returned by the method:

  The property is true.

  The property returns the current instance.

  The property is the same as the position of the object in the array.

  Generics are not supported by default; this property returns false if not overridden in a derived class. Generic constructors are not supported in the .NET Framework version 2.0, so this property returns false if the current instance is of type .

  For a list of the invariant conditions for terms specific to generic methods, see the property. For a list of the invariant conditions for other terms used in generic reflection, see the property.

  Gets a value indicating whether the method is a generic method definition.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Boolean To be added.

  When a member in a derived class is declared with the C# new modifier or the Visual Basic Shadows modifier, it can hide a member of the same name in the base class. C# hides base class members by signature. That is, if the base class member has multiple overloads, the only one that is hidden is the one that has the identical signature. By contrast, Visual Basic hides all the base class overloads. Thus, returns false on a member declared with the Visual Basic Shadows modifier, and true on a member declared with the C# new modifier.

  This property does not determine whether a method has the attribute. A method that is declared with either the new or the Shadows modifier will have the attribute, but only methods declared with new (that is, only C# methods) will have the property set to true. To determine whether a method has the attribute, use code similar to the following: if ((myMethodInfo.Attributes & MethodAttributes.VtableLayoutMask) == MethodAttributes.NewSlot) in C# or If (myMethodInfo.Attributes And MethodAttributes.VtableLayoutMask) = MethodAttributes.NewSlot in Visual Basic. Note, however, that although all methods declared with new or Shadows have the attribute, not all methods that have the attribute are declared with new or Shadows.

  Gets a value indicating whether only a member of the same kind with exactly the same signature is hidden in the derived class.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Boolean To be added.

  If a type member has Private level visibility, it can be called from any member in the same class and no others.

  Gets a value indicating whether this member is private.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Boolean To be added.

  To get the , first get the type. From the type, get the method. From the method, get the MethodBase. If the MethodBase or constructor is other than public, it is protected and cannot be readily accessed. To access a non-public method, set the mask to NonPublic in GetMethod.

  Gets a value indicating whether this is a public method.

- Property
  4.0.0.0
  System.Boolean To be added.

  The , , and properties report the transparency level of the method or constructor at its current trust level, as determined by the common language runtime (CLR). The combinations of these properties are shown in the following table:

  Security level

  IsSecurityCritical

  IsSecuritySafeCritical

  IsSecurityTransparent

  Critical

  true

  false

  false

  Safe critical

  true

  true

  false

  Transparent

  false

  false

  true

  Using these properties is much simpler than examining the security annotations of an assembly and its types and members, checking the current trust level, and attempting to duplicate the runtime's rules.

  For partial-trust assemblies, the value of this property depends on the current trust level of the assembly. If the assembly is loaded into a partially trusted application domain (for example, into a sandboxed application domain), the runtime ignores the security annotations of the assembly. The assembly and all its types are treated as transparent. The runtime pays attention to the security annotations of a partial-trust assembly only when that assembly is loaded into a fully trusted application domain (for example, into the default application domain of a desktop application). By contrast, a trusted assembly (that is, a strong-named assembly that is installed in the global assembly cache) is always loaded with full trust regardless of the trust level of the application domain, so its current trust level is always fully trusted. You can determine the current trust levels of assemblies and application domains by using the and properties.

  For more information about reflection and transparency, see Security Considerations for Reflection. For information about transparency, see Security Changes in the .NET Framework Version 4.0.

  Gets a value that indicates whether the current method or constructor is security-critical or security-safe-critical at the current trust level, and therefore can perform critical operations.

- Property
  4.0.0.0
  System.Boolean To be added.

  The , , and properties report the transparency level of the method or constructor at its current trust level, as determined by the common language runtime (CLR). The combinations of these properties are shown in the following table:

  Security level

  IsSecurityCritical

  IsSecuritySafeCritical

  IsSecurityTransparent

  Critical

  true

  false

  false

  Safe critical

  true

  true

  false

  Transparent

  false

  false

  true

  Using these properties is much simpler than examining the security annotations of an assembly and its types and members, checking the current trust level, and attempting to duplicate the runtime's rules.

  For partial-trust assemblies, the value of this property depends on the current trust level of the assembly. If the assembly is loaded into a partially trusted application domain (for example, into a sandboxed application domain), the runtime ignores the security annotations of the assembly. The assembly and all its types are treated as transparent. The runtime pays attention to the security annotations of a partial-trust assembly only when that assembly is loaded into a fully trusted application domain (for example, into the default application domain of a desktop application). By contrast, a trusted assembly (that is, a strong-named assembly that is installed in the global assembly cache) is always loaded with full trust regardless of the trust level of the application domain, so its current trust level is always fully trusted. You can determine the current trust levels of assemblies and application domains by using the and properties.

  For more information about reflection and transparency, see Security Considerations for Reflection. For information about transparency, see Security Changes in the .NET Framework Version 4.0.

  Gets a value that indicates whether the current method or constructor is security-safe-critical at the current trust level; that is, whether it can perform critical operations and can be accessed by transparent code.

- Property
  4.0.0.0
  System.Boolean To be added.

  If this property returns true, the and properties return false.

  The , , and properties report the transparency level of the method or constructor at its current trust level, as determined by the common language runtime (CLR). Using these properties is much simpler than examining the security annotations of an assembly and its types and members, checking the current trust level, and attempting to duplicate the runtime's rules.

  For partial-trust assemblies, the value of this property depends on the current trust level of the assembly. If the assembly is loaded into a partially trusted application domain (for example, into a sandboxed application domain), the runtime ignores the security annotations of the assembly. The assembly and all its types are treated as transparent. The runtime pays attention to the security annotations of a partial-trust assembly only when that assembly is loaded into a fully trusted application domain (for example, into the default application domain of a desktop application). By contrast, a trusted assembly (that is, a strong-named assembly that is installed in the global assembly cache) is always loaded with full trust regardless of the trust level of the application domain, so its current trust level is always fully trusted. You can determine the current trust levels of assemblies and application domains by using the and properties.

  For more information about reflection and transparency, see Security Considerations for Reflection. For information about transparency, see Security Changes in the .NET Framework Version 4.0.

  Gets a value that indicates whether the current method or constructor is transparent at the current trust level, and therefore cannot perform critical operations.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Boolean To be added.

  The bit is set to flag members that are treated in a special way by some compilers (such as property accessors and operator overloading methods).

  Gets a value indicating whether this method has a special name.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Boolean To be added.

  A static member cannot implicitly reference instance data in a class.

  Gets a value indicating whether the method is static.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Boolean To be added.

  A virtual member may reference instance data in a class and must be referenced through an instance of the class.

  To determine if a method is overridable, it is not sufficient to check that IsVirtual is true. For a method to be overridable, IsVirtual must be true and must be false. For example, a method might be non-virtual, but it implements an interface method. The common language runtime requires that all methods that implement interface members must be marked as virtual; therefore, the compiler marks the method virtual final. So there are cases where a method is marked as virtual but is still not overridable.

  To establish with certainty whether a method is overridable, use code such as this:

  if (MethodInfo.IsVirtual && !MethodInfo.IsFinal)

  If IsVirtual is false or IsFinal is true, then the method cannot be overridden.

  Gets a value indicating whether the method is virtual.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.RuntimeMethodHandle To be added.

  The handles are valid only in the application domain in which they were obtained.

  Gets a handle to the internal metadata representation of a method.

- Property
  4.0.0.0
  System.Reflection.MethodImplAttributes To be added.

  See the method for more information.

  Gets the flags that specify the attributes of a method implementation.

- Method
  4.0.0.0
  System.Boolean `` `` To be added.

  Indicates whether two objects are equal.

  true if is equal to ; otherwise, false.

  The first object to compare. The second object to compare.
- Method
  4.0.0.0
  System.Boolean `` `` To be added.

  Indicates whether two objects are not equal.

  true if is not equal to ; otherwise, false.

  The first object to compare. The second object to compare.
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Void `` `` `` `` `` To be added. To be added. To be added. To be added. To be added. To be added. To be added.
- Method
  4.0.0.0
  System.Type

  This member is an explicit interface member implementation. It can be used only when the instance is cast to an interface.

  For a description of this member, see .

  For a description of this member, see .

- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Void `` `` ``

  This method is for access to managed classes from unmanaged code, and should not be called from managed code. For more information about IDispatch::GetTypeInfo, see the MSDN Library.

  Retrieves the type information for an object, which can then be used to get the type information for an interface.

  The type information to return. The locale identifier for the type information. Receives a pointer to the requested type information object.
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Void `` To be added. To be added. To be added.
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Void `` `` `` `` `` `` `` `` To be added. To be added. To be added. To be added. To be added. To be added. To be added. To be added. To be added. To be added.
0