/* Mastering Visual C# .NET by Jason Price, Mike Gunderloy Publisher: Sybex; ISBN: 0782129110 */ /* Example18_4.cs illustrates unloading an application domain */ using System; using System.Runtime.Remoting; using System.Reflection; public class Example18_4 { public static void Main() { // create a new appdomain AppDomain d = AppDomain.CreateDomain("NewDomain"); // load an instance of the SimpleObject class ObjectHandle hobj = d.CreateInstance("Example18_2", "SimpleObject"); // use a local variable to access the object SimpleObject so = (SimpleObject) hobj.Unwrap(); Console.WriteLine(so.ToUpper("make this uppercase")); // unload the application domain AppDomain.Unload(d); Console.WriteLine(so.ToUpper("make this uppercase")); } } //=================================================== /* Example18_2.cs defines a simple object to create */ using System; [Serializable] public class SimpleObject { public String ToUpper(String inString) { return(inString.ToUpper()); } }
Author: coder
Illustrates runtime type invocation
/* Mastering Visual C# .NET by Jason Price, Mike Gunderloy Publisher: Sybex; ISBN: 0782129110 */ /* Example17_6 illustrates runtime type invocation */ using System; using System.Reflection; public class Example17_6 { public static void Main(string[] args) { RandomSupplier rs; RandomMethod rm; // iterate over all command-line arguments foreach(string s in args) { Assembly a = Assembly.LoadFrom(s); // Look through all the types in the assembly foreach(Type t in a.GetTypes()) { rs = (RandomSupplier) Attribute.GetCustomAttribute( t, typeof(RandomSupplier)); if(rs != null) { // find the method in this class. assume that // the class only contains a single method. // can't use GetMethod() because we don't know // what the method is named foreach(MethodInfo m in t.GetMethods()) { rm = (RandomMethod) Attribute.GetCustomAttribute( m, typeof(RandomMethod)); if(rm != null) { // create an instance of the class Object o = Activator.CreateInstance(t); // create an empty arguments array Object[] aa = new Object[0]; // invoke the method int i = (int) m.Invoke(o, aa); Console.WriteLine("Class {0} in {1} returned {2}", t, s, i); } } } } } } } /////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////// /* Mastering Visual C# .NET by Jason Price, Mike Gunderloy Publisher: Sybex; ISBN: 0782129110 */ /* Example17_5a compiles into a library defining the RamdomSupplier attribute and the RandomMethod attribute */ using System; // declare an attribute named RandomSupplier [AttributeUsage(AttributeTargets.Class)] public class RandomSupplier : Attribute { public RandomSupplier() { // doesn't have to do anything // we just use this attribute to mark selected classes } } // declare an attribute named RandomMethod [AttributeUsage(AttributeTargets.Method )] public class RandomMethod : Attribute { public RandomMethod() { // doesn't have to do anything // we just use this attribute to mark selected methods } } //=================================================== /* Example17_5b implements one class to supply random numbers */ // flag the class as a random supplier [RandomSupplier] public class OriginalRandom { [RandomMethod] public int GetRandom() { return 5; } } //=================================================== /* Example17_5c implements one class to supply random numbers */ using System; // flag the class as a random supplier [RandomSupplier] public class NewRandom { [RandomMethod] public int ImprovedRandom() { Random r = new Random(); return r.Next(1, 100); } } // this class has nothing to do with random numbers public class AnotherClass { public int NotRandom() { return 1; } } //=================================================== /* Example17_5d illustrates runtime type discovery */ using System; using System.Reflection; class Example17_5d { public static void Main(string[] args) { RandomSupplier rs; RandomMethod rm; // iterate over all command-line arguments foreach(string s in args) { Assembly a = Assembly.LoadFrom(s); // Look through all the types in the assembly foreach(Type t in a.GetTypes()) { rs = (RandomSupplier) Attribute.GetCustomAttribute( t, typeof(RandomSupplier)); if(rs != null) { Console.WriteLine("Found RandomSupplier class {0} in {1}", t, s); foreach(MethodInfo m in t.GetMethods()) { rm = (RandomMethod) Attribute.GetCustomAttribute( m, typeof(RandomMethod)); if(rm != null) { Console.WriteLine("Found RandomMethod method {0}" , m.Name ); } } } } } } }
Deeper Reflection: Invoking Functions
/* A Programmer's Introduction to C# (Second Edition) by Eric Gunnerson Publisher: Apress L.P. ISBN: 1-893115-62-3 */ // 36 - Deeper into C#Deeper ReflectionInvoking Functions // copyright 2000 Eric Gunnerson // file=driver.cs // compile with: csc driver.cs iprocess.cs using System; using System.Reflection; using MamaSoft; public class Deeper ReflectionInvokingFunctions { public static void ProcessAssembly(string aname) { Console.WriteLine("Loading: {0}", aname); Assembly a = Assembly.LoadFrom (aname); // walk through each type in the assembly foreach (Type t in a.GetTypes()) { // if it's a class, it might be one that we want. if (t.IsClass) { Console.WriteLine(" Found Class: {0}", t.FullName); // check to see if it implements IProcess if (t.GetInterface("IProcess") == null) continue; // it implements IProcess. Create an instance // of the object. object o = Activator.CreateInstance(t); // create the parameter list, call it, // and print out the return value. Console.WriteLine(" Calling Process() on {0}", t.FullName); object[] args = new object[] {55}; object result; result = t.InvokeMember("Process", BindingFlags.Default | BindingFlags.InvokeMethod, null, o, args); Console.WriteLine(" Result: {0}", result); } } } public static void Main(String[] args) { foreach (string arg in args) ProcessAssembly(arg); } } //======================================================= // 36 - Deeper into C#Deeper ReflectionInvoking Functions // copyright 2000 Eric Gunnerson // file=IProcess.cs namespace MamaSoft { interface IProcess { string Process(int param); } } //======================================================= // 36 - Deeper into C#Deeper ReflectionInvoking Functions // copyright 2000 Eric Gunnerson // file=process2.cs // compile with: csc /target:library process2.cs iprocess.cs using System; namespace MamaSoft { class Processor2: IProcess { Processor2() {} public string Process(int param) { Console.WriteLine("In Processor2.Process(): {0}", param); return("Shiver me timbers! "); } } class Unrelated { } } //======================================================== // 36 - Deeper into C#Deeper ReflectionInvoking Functions // copyright 2000 Eric Gunnerson // file=process1.cs // compile with: csc /target:library process1.cs iprocess.cs using System; namespace MamaSoft { class Processor1: IProcess { Processor1() {} public string Process(int param) { Console.WriteLine("In Processor1.Process(): {0}", param); return("Raise the mainsail! "); } } }
Utilize MyClass without assuming any prior knowledge
/*
C#: The Complete Reference
by Herbert Schildt
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/
// Utilize MyClass without assuming any prior knowledge.
using System;
using System.Reflection;
public class ReflectAssemblyDemo1 {
public static void Main() {
int val;
Assembly asm = Assembly.LoadFrom(“MyClasses.exe”);
Type[] alltypes = asm.GetTypes();
Type t = alltypes[0]; // use first class found
Console.WriteLine(“Using: ” + t.Name);
ConstructorInfo[] ci = t.GetConstructors();
// Use first constructor found.
ParameterInfo[] cpi = ci[0].GetParameters();
object reflectOb;
if(cpi.Length > 0) {
object[] consargs = new object[cpi.Length];
// initialize args
for(int n=0; n < cpi.Length; n++)
consargs[n] = 10 + n * 20;
// construct the object
reflectOb = ci[0].Invoke(consargs);
} else
reflectOb = ci[0].Invoke(null);
Console.WriteLine("
Invoking methods on reflectOb.");
Console.WriteLine();
// Ignore inherited methods.
MethodInfo[] mi = t.GetMethods(BindingFlags.DeclaredOnly |
BindingFlags.Instance |
BindingFlags.Public) ;
// Invoke each method.
foreach(MethodInfo m in mi) {
Console.WriteLine("Calling {0} ", m.Name);
// Get the parameters
ParameterInfo[] pi = m.GetParameters();
// Execute methods.
switch(pi.Length) {
case 0: // no args
if(m.ReturnType == typeof(int)) {
val = (int) m.Invoke(reflectOb, null);
Console.WriteLine("Result is " + val);
}
else if(m.ReturnType == typeof(void)) {
m.Invoke(reflectOb, null);
}
break;
case 1: // one arg
if(pi[0].ParameterType == typeof(int)) {
object[] args = new object[1];
args[0] = 14;
if((bool) m.Invoke(reflectOb, args))
Console.WriteLine("14 is between x and y");
else
Console.WriteLine("14 is not between x and y");
}
break;
case 2: // two args
if((pi[0].ParameterType == typeof(int)) &&
(pi[1].ParameterType == typeof(int))) {
object[] args = new object[2];
args[0] = 9;
args[1] = 18;
m.Invoke(reflectOb, args);
}
else if((pi[0].ParameterType == typeof(double)) &&
(pi[1].ParameterType == typeof(double))) {
object[] args = new object[2];
args[0] = 1.12;
args[1] = 23.4;
m.Invoke(reflectOb, args);
}
break;
}
Console.WriteLine();
}
}
}
//==============================================================
/*
C#: The Complete Reference
by Herbert Schildt
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/
// A file that contains three classes. Call this file MyClasses.cs.
using System;
class MyClass {
int x;
int y;
public MyClass(int i) {
Console.WriteLine("Constructing MyClass(int). ");
x = y = i;
show();
}
public MyClass(int i, int j) {
Console.WriteLine("Constructing MyClass(int, int). ");
x = i;
y = j;
show();
}
public int sum() {
return x+y;
}
public bool isBetween(int i) {
if((x < i) && (i < y)) return true;
else return false;
}
public void set(int a, int b) {
Console.Write("Inside set(int, int). ");
x = a;
y = b;
show();
}
// Overload set.
public void set(double a, double b) {
Console.Write("Inside set(double, double). ");
x = (int) a;
y = (int) b;
show();
}
public void show() {
Console.WriteLine("Values are x: {0}, y: {1}", x, y);
}
}
class AnotherClass {
string remark;
public AnotherClass(string str) {
remark = str;
}
public void show() {
Console.WriteLine(remark);
}
}
public class Demo12 {
public static void Main() {
Console.WriteLine("This is a placeholder.");
}
}
[/csharp]
Locate an assembly, determine types, and create an object using reflection
/*
C#: The Complete Reference
by Herbert Schildt
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/
/* Locate an assembly, determine types, and create
an object using reflection. */
using System;
using System.Reflection;
public class ReflectAssemblyDemo {
public static void Main() {
int val;
// Load the MyClasses.exe assembly.
Assembly asm = Assembly.LoadFrom(“MyClasses.exe”);
// Discover what types MyClasses.exe contains.
Type[] alltypes = asm.GetTypes();
foreach(Type temp in alltypes)
Console.WriteLine(“Found: ” + temp.Name);
Console.WriteLine();
// Use the first type, which is MyClass in this case.
Type t = alltypes[0]; // use first class found
Console.WriteLine(“Using: ” + t.Name);
// Obtain constructor info.
ConstructorInfo[] ci = t.GetConstructors();
Console.WriteLine(“Available constructors: “);
foreach(ConstructorInfo c in ci) {
// Display return type and name.
Console.Write(” ” + t.Name + “(“);
// Display parameters.
ParameterInfo[] pi = c.GetParameters();
for(int i=0; i < pi.Length; i++) { Console.Write(pi[i].ParameterType.Name + " " + pi[i].Name); if(i+1 < pi.Length) Console.Write(", "); } Console.WriteLine(")"); } Console.WriteLine(); // Find matching constructor. int x; for(x=0; x < ci.Length; x++) { ParameterInfo[] pi = ci[x].GetParameters(); if(pi.Length == 2) break; } if(x == ci.Length) { Console.WriteLine("No matching constructor found."); return; } else Console.WriteLine("Two-parameter constructor found. "); // Construct the object. object[] consargs = new object[2]; consargs[0] = 10; consargs[1] = 20; object reflectOb = ci[x].Invoke(consargs); Console.WriteLine(" Invoking methods on reflectOb."); Console.WriteLine(); MethodInfo[] mi = t.GetMethods(); // Invoke each method. foreach(MethodInfo m in mi) { // Get the parameters ParameterInfo[] pi = m.GetParameters(); if(m.Name.CompareTo("set")==0 && pi[0].ParameterType == typeof(int)) { // This is set(int, int). object[] args = new object[2]; args[0] = 9; args[1] = 18; m.Invoke(reflectOb, args); } else if(m.Name.CompareTo("set")==0 && pi[0].ParameterType == typeof(double)) { // This is set(double, double). object[] args = new object[2]; args[0] = 1.12; args[1] = 23.4; m.Invoke(reflectOb, args); } else if(m.Name.CompareTo("sum")==0) { val = (int) m.Invoke(reflectOb, null); Console.WriteLine("sum is " + val); } else if(m.Name.CompareTo("isBetween")==0) { object[] args = new object[1]; args[0] = 14; if((bool) m.Invoke(reflectOb, args)) Console.WriteLine("14 is between x and y"); } else if(m.Name.CompareTo("show")==0) { m.Invoke(reflectOb, null); } } } } //================================================================ /* C#: The Complete Reference by Herbert Schildt Publisher: Osborne/McGraw-Hill (March 8, 2002) ISBN: 0072134852 */ // A file that contains three classes. Call this file MyClasses.cs. using System; class MyClass { int x; int y; public MyClass(int i) { Console.WriteLine("Constructing MyClass(int). "); x = y = i; show(); } public MyClass(int i, int j) { Console.WriteLine("Constructing MyClass(int, int). "); x = i; y = j; show(); } public int sum() { return x+y; } public bool isBetween(int i) { if((x < i) && (i < y)) return true; else return false; } public void set(int a, int b) { Console.Write("Inside set(int, int). "); x = a; y = b; show(); } // Overload set. public void set(double a, double b) { Console.Write("Inside set(double, double). "); x = (int) a; y = (int) b; show(); } public void show() { Console.WriteLine("Values are x: {0}, y: {1}", x, y); } } class AnotherClass { string remark; public AnotherClass(string str) { remark = str; } public void show() { Console.WriteLine(remark); } } public class Demo12 { public static void Main() { Console.WriteLine("This is a placeholder."); } } [/csharp]
Demonstrate dynamically invoking an object
/* C# Programming Tips & Techniques by Charles Wright, Kris Jamsa Publisher: Osborne/McGraw-Hill (December 28, 2001) ISBN: 0072193794 */ // Invoke.cs -- Demonstrate dynamically invoking an object // // Compile this program with the following command line: // C:>csc Invoke.cs using System; using System.Reflection; namespace nsReflection { public class Invoke { static public void Main () { // Load the Circle assembly. Assembly asy = null; try { asy = Assembly.Load ("Circle"); } catch (Exception e) { Console.WriteLine (e.Message); return; } // Parameter array for a POINT object. object [] parmsPoint = new object [2] {15, 30}; // Parameter array for a clsCircle object. object [] parmsCircle = new object [3] {100, 15, 30}; // Get the type of clsCircle and create an instance of it. Type circle = asy.GetType("nsCircle.clsCircle"); object obj = Activator.CreateInstance (circle, parmsCircle); // Get the property info for the area and show the area PropertyInfo p = circle.GetProperty ("Area"); Console.WriteLine ("The area of the circle is " + p.GetValue(obj, null)); // Get the POINT type and create an instance of it Type point = asy.GetType("nsCircle.POINT"); object pt = Activator.CreateInstance (point, parmsPoint); // Show the point using object's ToString() method Console.WriteLine ("The point is " + pt.ToString ()); } } }
Using reflection to get information about an assembly
/* C# Programming Tips & Techniques by Charles Wright, Kris Jamsa Publisher: Osborne/McGraw-Hill (December 28, 2001) ISBN: 0072193794 */ // Asy.cs -- Demonstrates using reflection to get information // about an assembly. // // Compile this program with the following command line: // C:>csc Asy.cs using System; using System.Reflection; public class Asy { static public void Main () { Assembly asy = null; try { asy = Assembly.Load ("Circle"); } catch (Exception e) { Console.WriteLine (e.Message); return; } Type [] types = asy.GetTypes(); foreach (Type t in types) ShowTypeInfo (t); } static void ShowTypeInfo (Type t) { Console.WriteLine ("{0} is a member of the {1} namespace", t.Name, t.Namespace); Console.WriteLine (" Methods in {0}:", t.Name); MethodInfo [] methods = t.GetMethods (); foreach (MethodInfo m in methods) Console.WriteLine (" " + m.Name); Console.WriteLine (" Properties in {0}:", t.Name); PropertyInfo [] props = t.GetProperties (); foreach (PropertyInfo p in props) Console.WriteLine (" " + p.Name); Console.WriteLine (" Fields in {0}:", t.Name); FieldInfo [] fields = t.GetFields (); foreach (FieldInfo f in fields) Console.WriteLine (" " + f.Name); } }