[Serializable] |
| Attributes (inherited from System.Reflection.MethodBase) |
Read-only See base class member description: System.Reflection.MethodBase.Attributes Gets the attributes associated with this method. |
| CallingConvention (inherited from System.Reflection.MethodBase) |
Read-only See base class member description: System.Reflection.MethodBase.CallingConvention Gets a value indicating the calling conventions for this method. |
| DeclaringType (inherited from System.Reflection.MemberInfo) |
Read-only See base class member description: System.Reflection.MemberInfo.DeclaringType Gets the class that declares this member. |
| IsAbstract (inherited from System.Reflection.MethodBase) |
Read-only See base class member description: System.Reflection.MethodBase.IsAbstract Gets a value indicating whether the method is abstract. |
| IsAssembly (inherited from System.Reflection.MethodBase) |
Read-only See base class member description: System.Reflection.MethodBase.IsAssembly Gets a value indicating whether this method can be called by other classes in the same assembly. |
| IsConstructor (inherited from System.Reflection.MethodBase) |
Read-only See base class member description: System.Reflection.MethodBase.IsConstructor Gets a value indicating whether the method is a constructor. |
| IsFamily (inherited from System.Reflection.MethodBase) |
Read-only See base class member description: System.Reflection.MethodBase.IsFamily Gets a value indicating whether access to this method is restricted to members of the class and members of its derived classes. |
| IsFamilyAndAssembly (inherited from System.Reflection.MethodBase) |
Read-only See base class member description: System.Reflection.MethodBase.IsFamilyAndAssembly Gets a value indicating whether this method can be called by derived classes if they are in the same assembly. |
| IsFamilyOrAssembly (inherited from System.Reflection.MethodBase) |
Read-only See base class member description: System.Reflection.MethodBase.IsFamilyOrAssembly Gets a value indicating whether this method can be called by derived classes, wherever they are, and by all classes in the same assembly. |
| IsFinal (inherited from System.Reflection.MethodBase) |
Read-only See base class member description: System.Reflection.MethodBase.IsFinal Gets a value indicating whether this method is final. |
| IsHideBySig (inherited from System.Reflection.MethodBase) |
Read-only See base class member description: System.Reflection.MethodBase.IsHideBySig Gets a value indicating whether only a member of the same kind with exactly the same signature is hidden in the derived class. |
| IsPrivate (inherited from System.Reflection.MethodBase) |
Read-only See base class member description: System.Reflection.MethodBase.IsPrivate Gets a value indicating whether this member is private. |
| IsPublic (inherited from System.Reflection.MethodBase) |
Read-only See base class member description: System.Reflection.MethodBase.IsPublic Gets a value indicating whether this is a public method. |
| IsSpecialName (inherited from System.Reflection.MethodBase) |
Read-only See base class member description: System.Reflection.MethodBase.IsSpecialName Gets a value indicating whether this method has a special name. |
| IsStatic (inherited from System.Reflection.MethodBase) |
Read-only See base class member description: System.Reflection.MethodBase.IsStatic Gets a value indicating whether the method is static. |
| IsVirtual (inherited from System.Reflection.MethodBase) |
Read-only See base class member description: System.Reflection.MethodBase.IsVirtual Gets a value indicating whether the method is virtual. |
| MemberType | Read-only Overridden: Gets a value indicating that this member is a method. |
| MethodHandle (inherited from System.Reflection.MethodBase) |
Read-only See base class member description: System.Reflection.MethodBase.MethodHandle Gets a handle to the internal metadata representation of a method. |
| Name (inherited from System.Reflection.MemberInfo) |
Read-only See base class member description: System.Reflection.MemberInfo.Name Gets the name of this member. |
| ReflectedType (inherited from System.Reflection.MemberInfo) |
Read-only See base class member description: System.Reflection.MemberInfo.ReflectedType Gets the class object that was used to obtain this instance of MemberInfo. |
| ReturnType | Read-only Gets the return type of this method. |
| ReturnTypeCustomAttributes | Read-only Gets the custom attributes for the return type. |
| Equals (inherited from System.Object) |
See base class member description: System.Object.Equals Derived from System.Object, the primary base class for all objects. |
| GetBaseDefinition | When overridden in a derived class, returns the MethodInfo object for the method on the direct or indirect superclass in which the method represented by this instance was first declared. |
| GetCustomAttributes (inherited from System.Reflection.MemberInfo) |
Overloaded:GetCustomAttributes(bool inherit)See base class member description: System.Reflection.MemberInfo.GetCustomAttributesWhen overridden in a derived class, returns an array of all of the custom attributes. |
| GetCustomAttributes (inherited from System.Reflection.MemberInfo) |
Overloaded:GetCustomAttributes(Type attributeType, bool inherit)See base class member description: System.Reflection.MemberInfo.GetCustomAttributesWhen overridden in a derived class, returns an array of custom attributes identified by Type. |
| GetHashCode (inherited from System.Object) |
See base class member description: System.Object.GetHashCode Derived from System.Object, the primary base class for all objects. |
| GetMethodImplementationFlags (inherited from System.Reflection.MethodBase) |
See base class member description: System.Reflection.MethodBase.GetMethodImplementationFlags When overridden in a derived class, returns the MethodImplAttributes flags. |
| GetParameters (inherited from System.Reflection.MethodBase) |
See base class member description: System.Reflection.MethodBase.GetParameters When overridden in a derived class, gets the parameters of the specified method or constructor. |
| GetType (inherited from System.Object) |
See base class member description: System.Object.GetType Derived from System.Object, the primary base class for all objects. |
| Invoke (inherited from System.Reflection.MethodBase) |
Overloaded:Invoke(object obj, object[] parameters)See base class member description: System.Reflection.MethodBase.InvokeInvokes the underlying method or constructor represented by this MethodInfo object with the specified parameters. |
| Invoke (inherited from System.Reflection.MethodBase) |
Overloaded:Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)See base class member description: System.Reflection.MethodBase.InvokeWhen overridden in a derived class, invokes the reflected method or constructor with the given parameters. |
| IsDefined (inherited from System.Reflection.MemberInfo) |
See base class member description: System.Reflection.MemberInfo.IsDefined When overridden in a derived class, indicates whether one or more instance of attributeType is defined on this member. |
| ToString (inherited from System.Object) |
See base class member description: System.Object.ToString Derived from System.Object, the primary base class for all objects. |
| ctor #1 | Default constructor. This constructor is called by derived class constructors to initialize state in this type. Initializes a new instance of the MethodInfo class. |
| Finalize (inherited from System.Object) |
See base class member description: System.Object.Finalize Derived from System.Object, the primary base class for all objects. |
| MemberwiseClone (inherited from System.Object) |
See base class member description: System.Object.MemberwiseClone Derived from System.Object, the primary base class for all objects. |
Hierarchy:
protected MethodInfo(); |
public abstract MethodAttributes Attributes {get;}
|
To get the MethodAttributes, first get the type. From the type, get the method. From the method, get the MethodAttributes.
using System;
using System.Reflection;
class AttributesSample
{
public void Mymethod (int int1m, out string str2m, ref string str3m)
{
str2m = "in Mymethod";
}
public static int Main(string[] args)
{
Console.WriteLine ("Reflection.MethodBase.Attributes Sample");
// Get our type
Type MyType = Type.GetType("AttributesSample");
// Get the method Mymethod on our type
MethodBase Mymethodbase = MyType.GetMethod("Mymethod");
// Print out the method
Console.WriteLine("Mymethodbase = " + Mymethodbase);
// Get the MethodAttribute enumerated value
MethodAttributes Myattributes = Mymethodbase.Attributes;
// print out the flags set
PrintAttributes( typeof( System.Reflection.MethodAttributes ), (int) Myattributes );
return 0;
}
public static void PrintAttributes( Type attribType, int iAttribValue )
{
if ( ! attribType.IsEnum ) { Console.WriteLine( "This type is not an enum" ); return; }
FieldInfo[] fields = attribType.GetFields(BindingFlags.Public | BindingFlags.Static);
for ( int i = 0; i < fields.Length; i++ )
{
int fieldvalue = (Int32)fields[i].GetValue(null);
if ( (fieldvalue & iAttribValue) == fieldvalue )
{
Console.WriteLine( "\t" + fields[i].Name );
}
}
}
}
/*
This code produces the following output:
Reflection.MethodBase.Attributes Sample
Mymethodbase = Void Mymethod (Int32, System.String ByRef, System.String ByRef)
PrivateScope
FamANDAssem
Family
Public
HideBySig
ReuseSlot
*/
public virtual CallingConventions CallingConvention {get;}
|
public abstract Type DeclaringType {get;}
|
interface i {
int MyVar() ;
};
// DeclaringType for MyVar is i.
class A : i {
public int MyVar() { return 0; }
};
// DeclaringType for MyVar is A.
class B : A {
new int MyVar() { return 0; }
};
// DeclaringType for MyVar is B.
class C : A {
};
// DeclaringType for MyVar is A.
The following example uses DeclaringType to retrieve the member names of the System.IO.BufferedStream class, along with the class in which those members are declared.
using System;
using System.IO;
using System.Reflection;
class Mymemberinfo {
public static void Main(string[] args) {
Console.WriteLine ("\nReflection.MemberInfo");
//Get the Type and MemberInfo.
Type MyType =Type.GetType("System.IO.BufferedStream");
MemberInfo[] Mymemberinfoarray = MyType.GetMembers();
//Get and display the DeclaringType method.
Console.Write("\nThere are {0} members in ", Mymemberinfoarray.Length);
Console.Write("{0}.", MyType.FullName);
foreach (MemberInfo Mymemberinfo in Mymemberinfoarray) {
Console.Write("\n" + Mymemberinfo.Name + " declaring type - "
+ Mymemberinfo.DeclaringType);
}
}
}
This code produces the following output:
Reflection.MemberInfo
There are 31 members in System.IO.BufferedStream.
WriteByte declaring type - System.IO.BufferedStream
Write declaring type - System.IO.BufferedStream
ReadByte declaring type - System.IO.BufferedStream
Read declaring type - System.IO.BufferedStream
SetLength declaring type - System.IO.BufferedStream
Seek declaring type - System.IO.BufferedStream
EndWrite declaring type - System.IO.Stream
BeginWrite declaring type - System.IO.Stream
EndRead declaring type - System.IO.Stream
BeginRead declaring type - System.IO.Stream
Flush declaring type - System.IO.BufferedStream
Close declaring type - System.IO.BufferedStream
set_Position declaring type - System.IO.BufferedStream
get_Position declaring type - System.IO.BufferedStream
get_Length declaring type - System.IO.BufferedStream
get_CanWrite declaring type - System.IO.BufferedStream
get_CanSeek declaring type - System.IO.BufferedStream
get_CanRead declaring type - System.IO.BufferedStream
InitializeLifetimeService declaring type - System.MarshalByRefObject
GetHashCode declaring type - System.Object
Equals declaring type - System.Object
ToString declaring type - System.Object
GetLifetimeService declaring type - System.MarshalByRefObject
GetType declaring type - System.Object
.ctor declaring type - System.IO.BufferedStream
.ctor declaring type - System.IO.BufferedStream
CanRead declaring type - System.IO.BufferedStream
CanWrite declaring type - System.IO.BufferedStream
CanSeek declaring type - System.IO.BufferedStream
Length declaring type - System.IO.BufferedStream
Position declaring type - System.IO.BufferedStream
In the following code example, when B overrides virtual method M from A, it essentially redefines (or redeclares) this method. Therefore, B.M's MethodInfo reports the declaring type as B rather than A, even though A is where this method was originally declared.
class A {
virtual public void M () {}
}
class B: A {
override public void M () {}
}
public bool IsAbstract {get;}
|
To get the MethodBase, 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 BindingFlags mask to NonPublic in GetMethod.
class methodbase
{
public static int Main(string[] args)
{
Console.WriteLine ("\nReflection.MethodBase");
//Get the MethodBase of two methods.
//Get the types
Type MyType1 = Type.GetType("System.Runtime.Serialization.Formatter");
Type MyType2 = Type.GetType("System.Reflection.MethodBase");
//Get and display the methods
MethodBase Mymethodbase1 =
MyType1.GetMethod("WriteInt32", BindingFlags.NonPublic|BindingFlags.Instance);
MethodBase Mymethodbase2 =
MyType2.GetMethod("GetCurrentMethod", BindingFlags.Public|BindingFlags.Static);
Console.Write("\nMymethodbase = " + Mymethodbase1.ToString());
if (Mymethodbase1.IsAbstract)
Console.Write ("\nMymethodbase is an abstract method");
else
Console.Write ("\nMymethodbase is not an abstract method");
Console.Write("\n\nMymethodbase = " + Mymethodbase2.ToString());
if (Mymethodbase2.IsAbstract)
Console.Write ("\nMymethodbase is an abstract method");
else
Console.Write ("\nMymethodbase is not an abstract method");
return 0;
}
}
/*
Produces the following output
Reflection.MethodBase
Mymethodbase = Void WriteInt32 (Int32, System.String)
Mymethodbase is an abstract method
Mymethodbase = System.Reflection.MethodBase GetCurrentMethod ()
Mymethodbase is not an abstract method
*/
public bool IsAssembly {get;}
|
To get the MethodBase, 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 BindingFlags mask to NonPublic in GetMethod.
class methodbase
{
internal void f() { }
public static int Main(string[] args)
{
Console.WriteLine ("\nReflection.MethodBase");
//Get the MethodBase of two methods.
//Get the types
Type MyType1 = Type.GetType("System.Runtime.Serialization.Formatter");
Type MyType2 = Type.GetType("methodbase");
//Get and display the methods and the IsAssembly
MethodBase Mymethodbase1 =
MyType1.GetMethod("WriteInt32",BindingFlags.NonPublic|BindingFlags.Instance);
MethodBase Mymethodbase2 =
MyType2.GetMethod("f", BindingFlags.NonPublic|BindingFlags.Instance);
Console.Write("\nMymethodbase = " + Mymethodbase1.ToString());
if (Mymethodbase1.IsAssembly)
Console.Write ("\nMymethodbase is an assembly method");
else
Console.Write ("\nMymethodbase is not an assembly method");
Console.Write("\n\nMymethodbase = " + Mymethodbase2.ToString());
if (Mymethodbase2.IsAssembly)
Console.Write ("\nMymethodbase is an assembly method");
else
Console.Write ("\nMymethodbase is not an assembly method");
return 0;
}
}
/*
Produces the following output
Reflection.MethodBase
Mymethodbase = Void WriteInt32 (Int32, System.String)
Mymethodbase is not an assembly method
Mymethodbase = Void f()
Mymethodbase is an assembly method
*/
public bool IsConstructor {get;}
|
public bool IsFamily {get;}
|
public bool IsFamilyAndAssembly {get;}
|
public bool IsFamilyOrAssembly {get;}
|
public bool IsFinal {get;}
|
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.
using System;
using System.Reflection;
public class MyClass
{
public void MyMethod()
{
}
public static void Main()
{
MethodBase m = typeof(MyClass).GetMethod("MyMethod");
Console.WriteLine(m.IsFinal);
}
}
public bool IsHideBySig {get;}
|
public bool IsPrivate {get;}
|
public bool IsPublic {get;}
|
class methodbase
{
public static int Main(string[] args)
{
Console.WriteLine("\nReflection.MethodBase");
//Get the MethodBase of a method.
//Get the type
Type MyType = Type.GetType("System.MulticastDelegate");
//Get and display the method
MethodBase Mymethodbase =
MyType.GetMethod("RemoveImpl",BindingFlags.NonPublic);
Console.Write("\nMymethodbase = " + Mymethodbase);
bool Myispublic = Mymethodbase.IsPublic;
if (Myispublic)
Console.Write ("\nMymethodbase is a public method");
else
Console.Write ("\nMymethodbase is not a public method");
return 0;
}
}
/*
Produces the following output
Reflection.MethodBase
Mymethodbase = System.Delegate RemoveImpl (System.Delegate)
Mymethodbase is not a public method
*/
public bool IsSpecialName {get;}
|
public bool IsStatic {get;}
|
public bool IsVirtual {get;}
|
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 MethodBase.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 virtualfinal. 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.
using System;
using System.Reflection;
public class MyClass
{
public void MyMethod()
{
}
public static void Main()
{
MethodBase m = typeof(MyClass).GetMethod("MyMethod");
Console.WriteLine(m.IsFinal);
}
}
public override MemberTypes MemberType {get;}
|
To get the MemberType property, first get the class Type. From the Type, get the MethodInfo. From the MethodInfo, get the MemberType.
using System;
using System.Reflection;
class MyMethodInfo
{
public static int Main()
{
Console.WriteLine("Reflection.MethodInfo");
//Get the Type and MethodInfo.
Type MyType = Type.GetType("System.Reflection.FieldInfo");
MethodInfo Mymethodinfo = MyType.GetMethod("GetValue");
Console.WriteLine(MyType.FullName + "." + Mymethodinfo.Name);
//Get and display the MemberType property.
MemberTypes Mymembertypes = Mymethodinfo.MemberType;
if ( MemberTypes.Constructor == Mymembertypes )
{
Console.WriteLine( "MemberType is of type All" );
}
else if ( MemberTypes.Custom == Mymembertypes )
{
Console.WriteLine( "MemberType is of type Custom" );
}
else if ( MemberTypes.Event == Mymembertypes )
{
Console.WriteLine( "MemberType is of type Event" );
}
else if ( MemberTypes.Field == Mymembertypes )
{
Console.WriteLine( "MemberType is of type Field" );
}
else if ( MemberTypes.Method == Mymembertypes )
{
Console.WriteLine( "MemberType is of type Method" );
}
else if ( MemberTypes.Property == Mymembertypes )
{
Console.WriteLine( "MemberType is of type Property" );
}
else if ( MemberTypes.TypeInfo == Mymembertypes )
{
Console.WriteLine( "MemberType is of type TypeInfo" );
}
return 0;
}
}
/*
This code produces the following output:
Reflection.MethodInfo
System.Reflection.FieldInfo.GetValue
MemberType is of type Method
*/
public abstract RuntimeMethodHandle MethodHandle {get;}
|
public abstract string Name {get;}
|
To get the Name property, get the class Type. From the Type, get the MemberInfo array. From a MemberInfo element of the array, obtain the Name property.
using System;
using System.Reflection;
class Mymemberinfo
{
public static int Main()
{
Console.WriteLine ("\nReflection.MemberInfo");
//Get the Type and MemberInfo.
Type MyType = Type.GetType("System.Empty");
MemberInfo[] Mymemberinfoarray = MyType.GetMembers();
//Get and display the DeclaringType method.
Console.Write("\nThere are {0} members in ",
Mymemberinfoarray.GetLength(0));
Console.Write("{0}.", MyType.FullName);
foreach (MemberInfo Mymemberinfo in Mymemberinfoarray)
{
Console.Write("\n" + Mymemberinfo.Name
+ " declaring type - " +
Mymemberinfo.DeclaringType);
}
return 0;
}
}
/*
This code produces the following output:
Reflection.MemberInfo
There are 6 members in System.Empty.
Value declaring type - System.Empty
GetObjectData declaring type - System.Empty
GetHashCode declaring type - System.Object
Equals declaring type - System.Object
ToString declaring type - System.Empty
GetType declaring type - System.Object
*/
public abstract Type ReflectedType {get;}
|
In order to obtain a MethodInfo object:
using System;
using System.IO;
using System.Reflection;
class Mymemberinfo {
public static void Main(string[] args) {
Console.WriteLine ("\nReflection.MemberInfo");
//Get the Type and MemberInfo
Type MyType =Type.GetType("System.IO.BufferedStream");
MemberInfo[] Mymemberinfoarray = MyType.GetMembers();
//Get and display the DeclaringType method
Console.Write("\nThere are {0} members in ", Mymemberinfoarray.Length);
Console.Write("{0}.", MyType.FullName);
foreach (MemberInfo Mymemberinfo in Mymemberinfoarray) {
Console.Write("\n" + Mymemberinfo.Name + " reflected type - " +
Mymemberinfo.ReflectedType);
}
}
}
This code produces the following output: Reflection.MemberInfo
There are 31 members in System.IO.BufferedStream.
WriteByte reflected type - System.IO.BufferedStream
public abstract Type ReturnType {get;}
|
class Mymethodinfo
{
public static int Main()
{
Console.WriteLine ("\nReflection.MethodInfo");
//Get the Type and MethodInfo.
Type MyType = Type.GetType("System.Reflection.FieldInfo");
MethodInfo Mymethodinfo = MyType.GetMethod("GetValue");
Console.Write ("\n" + MyType.FullName + "." + Mymethodinfo.Name);
//Get and display the ReturnType.
Console.Write ("\nReturnType = {0}", Mymethodinfo.ReturnType);
return 0;
}
}
/*
This code produces the following output:
Reflection.MethodInfo
System.Reflection.FieldInfo.GetValue
ReturnType - System.Object
*/
public abstract ICustomAttributeProvider ReturnTypeCustomAttributes {get;}
|
~MethodInfo(); |
public abstract MethodInfo GetBaseDefinition(); |
If the method is declared on an interface, GetBaseDefinition returns the method.
If the method is defined in a base class, then GetBaseDefinition works as follows:
To get the GetBaseDefinition method , first get the class Type. From the Type, get the MethodInfo. From the MethodInfo, get the GetBaseDefinition.
using System;
using System.Reflection;
public class GetBaseDef {
public static void Main(String[] args)
{
Type t = typeof(B);
MethodInfo m;
// Print A Void B().
m = t.GetMethod("B");
Console.WriteLine(m.GetBaseDefinition().DeclaringType + " " + m.GetBaseDefinition());
// Print A Void C().
m = t.GetMethod("C");
Console.WriteLine(m.GetBaseDefinition().DeclaringType + " " + m.GetBaseDefinition());
// Print B Void D().
m = t.GetMethod("D", (BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.DeclaredOnly));
Console.WriteLine(m.GetBaseDefinition().DeclaringType + " " + m.GetBaseDefinition());
}
}
public class A
{
public virtual void B() { Console.WriteLine("C"); }
public virtual void C() { Console.WriteLine("C"); }
public virtual void D() { Console.WriteLine("E"); }
}
public class B : A
{
public override void C() { Console.WriteLine("C"); }
public new void D() { Console.WriteLine("D"); }
}
inherit
using System;
using System.Reflection;
// Define a custom attribute with one named parameter.
[AttributeUsage(AttributeTargets.All)]
public class MyAttribute : Attribute
{
private string myName;
public MyAttribute(string name)
{
myName = name;
}
public string Name
{
get
{
return myName;
}
}
}
// Define a class which has the custom attribute associated with one of its members.
public class MyClass1
{
[MyAttribute("This is an example attribute")]
public void MyMethod(int i)
{
return;
}
}
public class MemberInfo_GetCustomAttributes
{
public static void Main()
{
try
{
// Get the type of the class 'MyClass1'.
Type myType = typeof(MyClass1);
// Get the members associated with the class 'MyClass1'.
MemberInfo[] myMembers = myType.GetMembers();
// Display the attributes for each of the members of the class 'MyClass1'.
for(int i = 0; i < myMembers.Length; i++)
{
Object[] myAttributes = myMembers[i].GetCustomAttributes(false);
if(myAttributes.Length > 0)
{
Console.WriteLine("\nThe attributes for the member {0} are : \n", myMembers[i]);
for(int j = 0; j < myAttributes.Length; j++)
Console.WriteLine("The type of the attribute is : {0}", myAttributes[j]);
}
}
}
catch(Exception e)
{
Console.WriteLine("Exception Caught! "+e.Message);
}
}
}
attributeType
inherit
| Exception Type | Condition |
|---|---|
| TypeLoadException | If the custom attribute type can not be loaded. |
public virtual int GetHashCode(); |
public abstract MethodImplAttributes GetMethodImplementationFlags(); |
public abstract ParameterInfo[] GetParameters(); |
public Type GetType(); |
obj
parameters
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. If the parameters contain an uninitialized object, it is treated as System.Empty, which, with the default binder, can be widened to 0, 0.0 or String.
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. If the parameters contain an uninitialized object, it is treated as System.Empty, which, with the default binder, can be widened to 0, 0.0 or String.
| Exception Type | Condition |
|---|---|
| TargetException | The obj parameter is null and the method is not static. -or- The method is not declared or inherited by the class of obj. |
| ArgumentException | The type of the parameters parameter does not match the signature of the method or constructor reflected by this instance. |
| MemberAccessException | The caller does not have permission to invoke the method or constructor. |
| TargetInvocationException | The invoked method or constructor throws an exception. |
| TargetParameterCountException | The parameters array does not have the correct number of arguments. |
| MethodAccessException | The caller does not have permission to execute the constructor. |
For example, consider a method such as MyMethod(int x, float y = 2.0). To invoke this method with only the first argument as MyMethod(4), pass one of the above binding flags and pass two arguments, namely, 4 for the first argument and Missing.Value for the second argument. Unless you use Missing.Value, you may not omit optional parameters with the Invoke method. If you must do so, use Type.InvokeMember instead.
This is a convenience method that calls the following Invoke method, passing null in the other parameters. If the invoked method throws an exception, Exception.GetBaseException returns the exception.
To invoke a static method using its MethodInfo object, the first parameter should be null, as shown in the following call:
Object myReturnValue =
myMethodInfo.Invoke(null, myParametersArray);
public abstract object Invoke( |
obj
invokeAttr
binder
parameters
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. If the parameters contain an uninitialized object, it is treated as System.Empty, which, with the default binder, can be widened to 0, 0.0 or String.
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. If the parameters contain an uninitialized object, it is treated as System.Empty, which, with the default binder, can be widened to 0, 0.0 or String.
culture
| Exception Type | Condition |
|---|---|
| TargetException | The obj parameter is null and the method is not static. -or- The method is not declared or inherited by the class of obj. |
| ArgumentException | The type of the parameters parameter does not match the signature of the method or constructor reflected by this instance. |
| MemberAccessException | The caller does not have permission to invoke the method or constructor. |
| TargetInvocationException | The invoked method or constructor throws an exception. |
| MethodAccessException | The caller does not have permission to execute the constructor. |
You may not omit optional parameters in calls to Invoke. To invoke a method omitting optional parameters, you should call Type.InvokeMember instead.
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 parameters should be an array of Objects with length 2 such that
parameters[0] = new
Object("SomeString1") and parameters[1] = new Object("SomeString2")
.
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.
public class A
{
public virtual int method () {return 0;}
}
public class B
{
public virtual int method () {return 1;}
}
class Mymethodinfo
{
public static int Main()
{
Console.WriteLine ("\nReflection.MethodInfo");
A MyA = new A();
B MyB = new B();
//Get the Type and MethodInfo
Type MyTypea = Type.GetType("A");
MethodInfo Mymethodinfoa = MyTypea.GetMethod("method");
Type MyTypeb = Type.GetType("B");
MethodInfo Mymethodinfob = MyTypeb.GetMethod("method");
//Get and display the Invoke method
Console.Write("\nFirst method - " + MyTypea.FullName +
" returns " + Mymethodinfoa.Invoke(MyA, null));
Console.Write("\nSecond method - " + MyTypeb.FullName +
" returns " + Mymethodinfob.Invoke(MyB, null));
return 0;
}
}
attributeType
inherit
using System;
using System.Reflection;
// Define a custom attribute with one named parameter.
[AttributeUsage(AttributeTargets.All)]
public class MyAttribute : Attribute
{
private string myName;
public MyAttribute(string name)
{
myName = name;
}
public string Name
{
get
{
return myName;
}
}
}
// Define a class which has the custom attribute associated with one of its members.
public class MyClass1
{
[MyAttribute("This is an example attribute")]
public void MyMethod(int i)
{
return;
}
}
public class MemberInfo_GetCustomAttributes_IsDefined
{
public static void Main()
{
try
{
// Get the type of the class 'MyClass1'.
Type myType = typeof(MyClass1);
// Get the members associated with the class 'MyClass1'.
MemberInfo[] myMembers = myType.GetMembers();
// Display the attributes for each of the members of the class 'MyClass1'.
for(int i = 0; i < myMembers.Length; i++)
{
// Display the attribute if it is of type 'MyAttribute'.
if(myMembers[i].IsDefined(typeof(MyAttribute), false))
{
Object[] myAttributes = myMembers[i].GetCustomAttributes(typeof(MyAttribute), false);
Console.WriteLine("\nThe attributes of type 'MyAttribute' for the member {0} are : \n",
myMembers[i]);
for(int j = 0; j < myAttributes.Length; j++)
// Display the value associated with the attribute.
Console.WriteLine("The value of the attribute is : \"{0}\"",
((MyAttribute)myAttributes[j]).Name);
}
}
}
catch(Exception e)
{
Console.WriteLine("Exception Caught! "+e.Message);
}
}
}
protected object MemberwiseClone(); |
public virtual string ToString(); |