如何通过反射调用方法？

// calling a static method, receiving no arguments

// don't forget that we are using object in the reflection namespace...
using System;
using System.Reflection;

public class Invoke {

public static void Main (String [] cmdargs) {

// Declare a type object, used to call our InvokeMember method...
Type t = typeof (TestClass);

// BindingFlags has three bitor'ed elements. Default indicates
// that default binding rules should be applied.
t.InvokeMember ("SayHello",
BindingFlags.Default | BindingFlags.InvokeMethod
| BindingFlags.Static, null,
null, new object [] {});
}
}

'  calling a static method, receiving no arguments

'  don't forget that we are using object in the reflection namespace...
Imports System
Imports System.Reflection

Public Class Invoke

Public Shared Sub Main ()

'  Declare a type object, used to call our InvokeMember method...
Dim t As Type = GetType (TestClass)

'  BindingFlags has three bitor'ed elements. Default indicates that
'  default binding rules should be applied.
t.InvokeMember ("SayHello", _
BindingFlags.Default BitOr BindingFlags.InvokeMethod _
BitOr BindingFlags.Static, nothing, _
nothing, new object () {})
End Sub
End Class

// Calling a static method, which needs arguments
object [] args = new object [] {100.09, 184.45};

// we know that this particular method returns a value, being the computed sum,
// so we create a variable to hold the return
// note the datatype of the return is object, the only datatype InvokeMethod returns...
object result;

// invoke the method. Note the change in the last parameter: the array we populated...
result = t.InvokeMember ("ComputeSum", BindingFlags.Default | _
BindingFlags.InvokeMethod | BindingFlags.Static,
null, null, args);

// write the results to the user's console...
Console.WriteLine ("{0} + {1} = {2}", args[0], args[1], result);

'  Calling a static method, which needs arguments
Dim args as object ()
args = new object () {100.09, 184.45}

'  we know that this particular method returns a value, being the computed sum,
'  so we create a variable to hold the return
'  note the datatype of the return is object, the only datatype InvokeMethod returns...
Dim result As object

'  invoke the method. Note the change in the last parameter: the array we populated...
result = t.InvokeMember ("ComputeSum", BindingFlags.Default BitOr _
BindingFlags.InvokeMethod BitOr BindingFlags.Static, _
nothing, nothing, args)

'  write the results to the user's console...
Console.WriteLine ("{0} + {1} = {2}", args(0), args(1), result)

// Calling  an instance method
// we need an object reference to invoke an instance member
TestClass c = new TestClass ();

// use the instance of our class to call GetType
// we no longer include the Static element in BindingFlags for our |
// the fourth parameter is no longer null: we instead pass an instance
// of the object we wish to invoke our method on
c.GetType().InvokeMember ("AddUp", BindingFlags.Default | BindingFlags.InvokeMethod,
null, c, new object [] {});
c.GetType().InvokeMember ("AddUp", BindingFlags.Default | BindingFlags.InvokeMethod,
null, c, new object [] {});

'  Calling  an instance method
'  we need an object reference to invoke an instance member
Dim c as TestClass
c = new TestClass ()

'  use the instance of our class to call GetType
'  we no longer include the Static element in BindingFlags for our bitor
'  the fourth parameter is no longer null: we instead pass an instance
'  of the object we wish to invoke our method on
c.GetType().InvokeMember ("AddUp", BindingFlags.Default BitOr BindingFlags.InvokeMethod, _
nothing, c, new object () {})
c.GetType().InvokeMember ("AddUp", BindingFlags.Default BitOr BindingFlags.InvokeMethod, _
nothing, c, new object () {})

// Setting a field. Assume we are using the same Type and Class declared in the
// previous examples (t and c). The field we are setting is the Name field
// note the BindingFlags argument now includes SetField rather thanInvokeMember
// Further, this is an instance field, so we pass the instance of our class
t.InvokeMember ("Name", BindingFlags.Default | BindingFlags.SetField,
null, c, new object [] {"NewName"});

// similar usage...
result = t.InvokeMember ("Name", BindingFlags.Default | BindingFlags.GetField,
null, c, new object [] {});

Console.WriteLine ("Name == {0}", result);

'  Setting a field. Assume we are using the same Type and Class declared in the
'  previous examples (t and c). The field we are setting is the Name field
'  note the BindingFlags argument now includes SetField rather thanInvokeMember
'  Further, this is an instance field, so we pass the instance of our class
t.InvokeMember ("Name", BindingFlags.Default BitOr BindingFlags.SetField, _
nothing, c, new object () {"NewName"})

'  similar usage...
result = t.InvokeMember ("Name", BindingFlags.Default BitOr BindingFlags.GetField, _
nothing, c, new object () {})

Console.WriteLine ("Name == {0}", result)

// Set an indexed property value
int index = 3;

// specify BindingFlags.SetProperty, and because this is an instance property,
// pass the object to call the property on (c). In the object array, make two elements,
// the first being the index, and the second being the value to set
t.InvokeMember ("Item", BindingFlags.Default |BindingFlags.SetProperty,
null, c, new object [] {index, "NewValue"});

// Get an indexed property value
// specify BindingFlags.GetProperty, and because this is an instance property,
// pass the object to call the property on (c). In the object array, specify the index only
result = t.InvokeMember ("Item", BindingFlags.Default |BindingFlags.GetProperty,
null, c, new object [] {index});

Console.WriteLine ("Item[{0}] == {1}", index, result);

' Set an indexed property value
Dim  index As Int32 = 3

'  specify BindingFlags.SetProperty, and because this is an instance property,
'  pass the object to call the property on (c). In the object array, make two elements,
'  the first being the index, and the second being the value to set
t.InvokeMember ("Item", BindingFlags.Default BitOr BindingFlags.SetProperty, _
nothing, c, new object () {index, "NewValue"})

'  Get an indexed property value
'  specify BindingFlags.GetProperty, and because this is an instance property,
'  pass the object to call the property on (c). In the object array, specify the index only
result = t.InvokeMember ("Item", BindingFlags.Default BitOr BindingFlags.GetProperty, _
nothing, c, new object () {index})

Console.WriteLine ("Item[{0}] == {1}", index, result)

// Calling a method using named arguments

// the argument array, and the parameter name array. Obviously, you will need
// to determine the names of the parameters in advance
object[] argValues = new object [] {"Mouse", "Micky"};
String [] argNames = new String [] {"lastName", "firstName"};

// the first five parameters for this overloaded method are the same as the
// the five parameters we have used to this point. The final parameter needs to be
// set to the names of the parameters
t.InvokeMember ("PrintName", BindingFlags.Default | BindingFlags.InvokeMethod,
null, null, argValues, null, null, argNames);

'  Calling a method using named arguments

'  the argument array, and the parameter name array. Obviously, you will need
'  to determine the names of the parameters in advance
object[] argValues = new object [] {"Mouse", "Micky"};
String [] argNames = new String [] {"lastName", "firstName"};

'  the first five parameters for this overloaded method are the same as the
'  the five parameters we have used to this point. The final parameter needs to be
'  set to the names of the parameters
t.InvokeMember ("PrintName", BindingFlags.Default BitOr BindingFlags.InvokeMethod, _
nothing, nothing, argValues, nothing, nothing, argNames)

// our class with it's default member specified, using the defaultmemeber attribute
[DefaultMemberAttribute ("PrintTime")]
public class TestClass2 {

public void PrintTime () {
Console.WriteLine (DateTime.Now);
}
}

// the client code that uses the above class...

Type t3 = typeof (TestClass2);
t3.InvokeMember ("", BindingFlags.Default |BindingFlags.InvokeMethod,
null, new TestClass2(), new object [] {});

'  our class with it's default member specified, using the defaultmemeber attribute

public  class  TestClass2

public Sub PrintTime ()
Console.WriteLine (DateTime.Now)
End Sub
End Class

'  the client code that uses the above class...
Dim t3 As Type

t3 = GetType (TestClass2)
t3.InvokeMember ("", BindingFlags.Default  BitOr BindingFlags.InvokeMethod, _
nothing, new TestClass2(), new object () {})

// Invoking a ByRef member
MethodInfo m = t.GetMethod("Swap");

args = new object[2];
args[0] = 1;
args[1] = 2;

m.Invoke(new TestClass(),args);

Console.WriteLine ("{0}, {1}", args[0], args[1]);

'  Invoking a ByRef member
Dim m as MethodInfo =
m = t.GetMethod("Swap")

args = new object() {CObj(1), CObj(2)}

m.Invoke(new TestClass(),args)

Console.WriteLine ("{0}, {1}", args(0), args(1))