|
|
|
Reflection
Beispiel "Assembly"
In diesem Beispiel wird ein Assembly "mscorelib.dll" geladen und alle darin enthaltenen Typen auf der Konsole ausgegeben.
../../../samples/4/Reflection/AssemblyExample.cs
using System;
using System.Reflection;
namespace Kapitel4.Reflection {
public class AssemblyExample {
public static void Main(string[] argv) {
Assembly a = Assembly.Load("mscorlib");
Type[] types = a.GetTypes();
foreach (Type t in types)
Console.WriteLine(t.FullName);
}
}
}
|
Beispiel "Type"
In diesem Beispiel wird ein Objekt vom Typ string angelegt, dessen Typinformation abgefragt und auf der Konsole ausgegeben.
../../../samples/4/Reflection/TypeExample.cs
using System;
using System.Reflection;
namespace Kapitel4.Reflection {
public class TypeExample {
public static void Main(string[] argv) {
string s = "Hello";
Type t = s.GetType ();
Console.WriteLine("s ist vom Typ: {0}", t.FullName);
Console.WriteLine("direkter Basistyp: {0}", t.BaseType);
Console.WriteLine("Der Typ implementiert folgende Interfaces:");
foreach (Type i in t.GetInterfaces())
Console.WriteLine(" {0}", i.FullName);
Console.WriteLine("Er besitzt folgende Konstruktoren:");
foreach (ConstructorInfo i in t.GetConstructors())
Console.WriteLine(" {0}", i);
Console.WriteLine("Er besitzt folgende Properties:");
foreach (PropertyInfo i in t.GetProperties())
Console.WriteLine(" {0}", i);
}
}
}
|
Beispiel "Activator"
In diesem Beispiel wird ein Objekt vom Typ string mit Hilfe der Klasse Activator dynamisch erzeugt, wobei die Parameter des Konstruktors als Objekt-Array
übergeben werden. Die Parametertypen bestimmen dann den Konstruktor des jeweiligen Typs:
../../../samples/4/Reflection/ActivatorExample.cs
using System;
using System.Reflection;
namespace Kapitel4.Reflection {
public class ActivatorExample {
public static void Main(string[] argv) {
Type t = Type.GetType("System.String");
object[] args = new object[] { new char[]{'T','e','s','t'} };
string s = (string) Activator.CreateInstance(t, args);
Console.WriteLine(s);
}
}
}
|
Beispiel "Methodensuche"
In diesem Beispiel wird ein Objekt vom Typ string erzeugt und alle Methoden dieses Typs auf der Konsole aufgelistet, bzw. alle Methode die static public sind.
../../../samples/4/Reflection/MethodExample.cs
using System;
using System.Reflection;
namespace Kapitel4.Reflection {
public class MethodExample {
public static void Main(string[] argv) {
// Suchen einer bestimmten Methode des Typs String
Console.WriteLine("-----Alle Methoden des Typs String-----");
Type t = typeof(System.String);
MethodInfo[] methods = t.GetMethods();
foreach (MethodInfo m in methods) Console.WriteLine(m);
// Einschr�nken der Suche mit Hilfe von Flags
Console.WriteLine("-----Alle static public Methoden des Typs String-----");
t = typeof(string);
methods = t.GetMethods(BindingFlags.Static | BindingFlags.Public);
foreach (MethodInfo m in methods) Console.WriteLine(m);
}
}
}
|
Beispiel "Dynamischer Methodenaufruf"
In diesem Beispiel wird ein Objekt vom Typ string erzeugt, die Methoden ToLower() und IndexOf(int pos) gesucht und dynamisch aufgerufen:
../../../samples/4/Reflection/MethodInvokeExample.cs
using System;
using System.Reflection;
namespace Kapitel4.Reflection {
public class MethodInvokeExample {
public static void Main(string[] argv) {
//----- Erzeugen eines String-Objekts
Type t = typeof(string);
object[] args = new object[]{ new char[]{'F','o','O','B','A','r'} };
string s = (string)Activator.CreateInstance (t, args);
Console.WriteLine("Vor der Anwendung der Methode ToLower (): {0}", s);
//----- Suche und Aufruf von s.ToLower ():
MethodInfo method = t.GetMethod("ToLower", new Type[0]); // kein Parameter
object result = method.Invoke(s, new object[0]); // kein Parameter
Console.WriteLine("R�ckgabe der Methode ToLower (): {0}", result);
//----- Suche und Aufruf von IndexOf mit einem Parameter vom Typ int
Type[] parTypes = { typeof(char), typeof(int) };
method = t.GetMethod("IndexOf", parTypes);
object[] parameters = { 'B', 1 };
object ret = method.Invoke(s, parameters);
Console.WriteLine("Ergebnis des dynamischen Aufrufs Methode IndexOf:" + ret);
}
}
}
|
Beispiel "Dynamische Erzeugung von Assemblies zur Laufzeit"
In diesem Beispiel wird gezeigt wie ein Assembly zur Laufzeit erzeugt wird. Das Assembly enthält eine Klasse "HelloWorld" welche die Zeichenkette
"Hello Wolfgang" auf der Konsole ausgibt:
../../../samples/4/Reflection/EmitExample.cs
using System;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;
namespace Kapitel4.Reflection {
public class EmitExample {
public static void Main(string[] argv) {
//----- Erzeugen eines Assemblies
AssemblyName assemblyName = new AssemblyName();
assemblyName.Name = "HelloWorldAssembly";
AssemblyBuilder newAssembly =
Thread.GetDomain().DefineDynamicAssembly(assemblyName,
AssemblyBuilderAccess.RunAndSave);
//----- Erzeugen eines Moduls im neuen Assembly
ModuleBuilder newModule = newAssembly.DefineDynamicModule("HelloWorldModule");
//----- Erzeugen eines Typs im neuen Modul
TypeBuilder newType = newModule.DefineType("HelloWorld", TypeAttributes.Public);
//----- Erzeugen einer Methode mit ihren Parametertypen im neuen Typ
Type[] paramTypes = { typeof(string) };
Type retType = typeof(string);
MethodBuilder newMethod = newType.DefineMethod("SayHelloTo",
MethodAttributes.Public | MethodAttributes.Virtual, retType, paramTypes);
//----- Einf�gen der CIL-Instruktionen in die neu erzeugte Methode:
ILGenerator ilGen = newMethod.GetILGenerator();
ilGen.Emit(OpCodes.Ldstr, "Hello ");
ilGen.Emit(OpCodes.Ldarg_1);
Type t = typeof(string);
MethodInfo mi = t.GetMethod("Concat", new Type[] {typeof(string),typeof(string)});
ilGen.Emit(OpCodes.Call, mi);
ilGen.Emit(OpCodes.Ret);
//----- Schlie�e den neuen Typ ab
newType.CreateType();
//----- F�hre die neu erzeugte Methode SayHelloTo("Wolfgang") aus
MethodInfo method = newType.GetMethod("SayHelloTo", new Type[] {typeof(string)});
object obj = Activator.CreateInstance(newType);
object ret = method.Invoke(obj, new string[]{"Wolfgang"});
Console.WriteLine(ret);
}
}
}
|
|
