如何通过反射调用方法？

// 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,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,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,'  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,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,c,new object [] {});
c.GetType().InvokeMember ("AddUp",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,new object () {})
c.GetType().InvokeMember ("AddUp",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,new object [] {"NewName"});

// similar usage...
result = t.InvokeMember ("Name",BindingFlags.Default | BindingFlags.GetField,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,BindingFlags.Default BitOr BindingFlags.SetField,new object () {"NewName"})

'  similar usage...
result = t.InvokeMember ("Name",BindingFlags.Default BitOr BindingFlags.GetField,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,new object [] {index,"NewValue"});

// Get an indexed property value
// specify BindingFlags.GetProperty,specify the index only
result = t.InvokeMember ("Item",BindingFlags.Default |BindingFlags.GetProperty,new object [] {index});

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

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

'  specify BindingFlags.SetProperty,'  pass the object to call the property on (c). In the object array,'  the first being the index,BindingFlags.Default BitOr BindingFlags.SetProperty,new object () {index,"NewValue"})

'  Get an indexed property value
'  specify BindingFlags.GetProperty,BindingFlags.Default BitOr BindingFlags.GetProperty,new object () {index})

Console.WriteLine ("Item[{0}] == {1}",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",argValues,argNames);

'  Calling a method using named arguments

'  the argument array,you will need
'  to determine the names of the parameters in advance
object[] argValues = new object [] {"Mouse","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",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,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,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[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},args(1))