haoxiaobo

// 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))

// don't forget your using statements at the top of your code...
Using System;
Using System.Reflection;

// class declaration, and method declaration...

// remember that this string is case-sensitive, so be careful
Type t = Type.GetType("System.String");

// check to see if we have a valid value. If our object is null, the type does not exist...
if (t == null) {
	// Don't assume that it is a SYSTEM datatype...
	Console.WriteLine("Please ensure you specify only valid types in the type field.");
	Console.WriteLine("REMEMBER: The Case matters (Byte is not the same as byte).");

	return; // don't continue processing
}

'  don't forget your imports statements at the top of your code...
Imports System
Imports System.Reflection

'  class declaration, and method declaration...

'  remember that this string is case-sensitive, so be careful
Dim t As Type = Type.GetType("System.String")

'  check to see if we have a valid value. If our object is null, the type does not exist...
If t Is Nothing Then
	'  Don't assume that it is a SYSTEM datatype...
	Console.WriteLine("Please ensure you specify only valid types in the type field.")
	Console.WriteLine("REMEMBER: The Case matters (Byte is not the same as byte).")

	Exit Sub ' don't continue processing
End If

// declare and populate the arrays to hold the information...
FieldInfo [] fi = t.GetFields (BindingFlags.Static |
		BindingFlags.NonPublic | BindingFlags.Public);     // fields

MethodInfo [] mi = t.GetMethods (BindingFlags.Static |
		BindingFlags.NonPublic | BindingFlags.Public);     // methods

'  declare and populate the arrays to hold the information...
Dim fi() As FieldInfo = t.GetFields(BindingFlags.Static BitOr _
		BindingFlags.NonPublic BitOr BindingFlags.Public)  '  fields

Dim mi() As MethodInfo = t.GetMethods(BindingFlags.Static BitOr _
		BindingFlags.NonPublic BitOr BindingFlags.Public)  '  methods

// iterate through all the method members
foreach (MethodInfo m in mi) {
	Console.WriteLine(m);
}

// iterate through all the field members
foreach (FieldInfo f in fi) {
	Console.WriteLine(f);
}

// etc.... for each array type

Dim m As MethodInfo
Dim f As FieldInfo

'  iterate through all the method members...
For Each m In mi
	Console.WriteLine(m)
Next m

'  iterate through all the field members
For Each f In fi
	Console.WriteLine(f)
Next f

'  etc.... for each array type

// call the routine below, passing the relevant array we made in the previous step
PrintMembers( mi ); // the method information
PrintMembers( fi ); // the field information

void PrintMembers (MemberInfo [] ms ) {



	// MemberInfo is the generic info object. This can be any of the other info objects.
	foreach (MemberInfo m in ms) {
		Console.WriteLine(m);
	}
}

'  call the routine below, passing the relevant array we made in the previous step
PrintMembers( mi )  '  the method information
PrintMembers( fi )  '  the field information

Sub PrintMembers (ms() As MemberInfo)

	Dim m As MemberInfo

	'  MemberInfo is the generic info object. This can be any of the other info objects.
	For Each  m in ms
		Console.WriteLine(m)
	Next m
End Sub

// don't forget your using statements
using System;
using System.Reflection;
// ...

// Getting an Assembly, method 1. Get the mscorlib assembly
// Note that other types such as String, or Int32 would have worked just as well,
// since they reside in the same assembly
Assembly a = typeof(Object).Module.Assembly;

// Getting an Assembly, method 2. Load a particular assembly, using a reference to a
// module that is within that assembly. Note that this requires a compiled module for
// the reference, and when running in an aspx page, will require a fully qualifed path
// to the file, to ensure it is correctly identified
Assembly b = Assembly.LoadFrom ("GetTypes.exe");

// note that either of the above methods is viable, depending on the information
// you have. Since we know the name of the file which houses all of the base system
// objects, we could do the following to replace the first example, just as effectively
// (the absolute path may change on your machine)
// Assembly a = Assembly.LoadFrom
//			("c:/winserv/microsoft.net/framework/v1.0.2230/mscorlib.dll");

'  don't forget your using statements
Imports System
Imports System.Reflection
' ...

'  Getting an Assembly, method 1. Get the mscorlib assembly
'  Note that other types such as String, or Int32 would have worked just as well,
'  since they reside in the same assembly
Dim a As reflection.Assembly = GetType(Object).Module.Assembly

'  Getting an Assembly, method 2. Load a particular assembly, using a reference to a
'  module that is within that assembly. Note that this requires a compiled module for
'  the reference, and when running in an aspx page, will require a fully qualifed path
'  to the file, to ensure it is correctly identified
Dim b As reflection.Assembly = reflection.Assembly.LoadFrom ("GetTypes.exe")

'  note that either of the above methods is viable, depending on the information
'  you have. Since we know the name of the file which houses all of the base system
'  objects, we could do the following to replace the first example, just as effectively
'  (the absolute path may change on your machine)
'  Dim a As reflection.Assembly = reflection.Assembly.LoadFrom _
'			("c:/winserv/microsoft.net/framework/v1.0.2230/mscorlib.dll")

//Get all the types in the assembly identified in the previous example
Type [] types = a.GetTypes ();

int numInterfaces = 0;



foreach (Type t in types) {

	//the following line uses a set of methods which identify what
	//kind of type we are currently querying
	if (t.IsInterface) {
		// only print out the names of the Interfaces
		Console.WriteLine (t.Name + "");
		numInterfaces++;
	}
}

// write out the totals
Console.WriteLine("Out of {0} types in the {1} library:",
			types.Length, typeof(Object).Module.ToString());
Console.WriteLine ("{0} are interfaces (listed)", types.Length, numInterfaces);

' Get all the types in the assembly identified in the previous example
Dim types() As Type = a.GetTypes ()

Dim numInterfaces As Integer = 0

Dim t As Type

For Each t in types

	' the following line uses a set of methods which identify what
	' kind of type we are currently querying
	If t.IsInterface Then
		'  only print out the names of the Interfaces
		Console.WriteLine (t.Name + "'")
		numInterfaces = numInterfaces + 1
	End If
Next t

'  write out the totals
Console.WriteLine("Out of {0} types in the {1} library:", _
			types.Length, GetType(Object).Module.ToString())
Console.WriteLine ("{0} are interfaces (listed)", types.Length, numInterfaces)

// Get all the types in the assembly identified in the previous example (this assembly)
Type [] types2 = b.GetTypes ();

Console.WriteLine ("Get all the types from the assembly: '{0}'", b.GetName());

foreach (Type t in types2)
{
    Console.WriteLine (t.FullName);
}

'  Get all the types in the assembly identified in the previous example (this assembly)
Dim types2() As Type = b.GetTypes ()

Console.WriteLine ("Get all the types from the assembly: '{0}'", b.GetName())

For Each t in types2

	Console.WriteLine(t.FullName) ' not many types, so we can print them all
Next t