Csharp/C Sharp/Reflection/MethodInfo

Analyze methods using reflection

/*
C#: The Complete Reference 
by Herbert Schildt 
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/

// Analyze methods using reflection. 
 
using System; 
using System.Reflection; 
 
class MyClass { 
  int x; 
  int y; 
 
  public MyClass(int i, int j) { 
    x = i; 
    y = j; 
  } 
 
  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) { 
    x = a; 
    y = b; 
  } 
 
  public void set(double a, double b) { 
    x = (int) a; 
    y = (int) b; 
  } 
 
  public void show() { 
    Console.WriteLine(" x: {0}, y: {1}", x, y); 
  } 
} 
 
public class ReflectDemo { 
  public static void Main() { 
    Type t = typeof(MyClass); // get a Type object representing MyClass 
 
    Console.WriteLine("Analyzing methods in " + t.Name);     
    Console.WriteLine(); 
 
    Console.WriteLine("Methods supported: "); 
 
    MethodInfo[] mi = t.GetMethods(); 
 
    // Display methods supported by MyClass. 
    foreach(MethodInfo m in mi) { 
      // Display return type and name. 
      Console.Write("   " + m.ReturnType.Name + 
                      " " + m.Name + "("); 
 
      // Display parameters. 
      ParameterInfo[] pi = m.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(); 
    } 
  } 
}

dump the public methods of a class

 

using System;
using System.Reflection;
class DumpType {
    static void Main(string[] argv) {
        targetType = LoadAssembly(argv[0], argv[1]);
        DumpReportHeader();
        DumpMethods();
    }
    static public Type LoadAssembly(string t, string a) {
        return Type.ReflectionOnlyGetType(t + "," + a, false, true);
    }
    static void DumpReportHeader() {
        Console.WriteLine("\n{0} type of {1} assembly",targetType.Name, targetType.Assembly.GetName().Name);
        Console.WriteLine("\n{0,22}\n", "[ METHODS ]");
    }
    static void DumpMethods() {
        string dashes = new string("-", 50);
        foreach (MethodInfo method in targetType.GetMethods()) {
            Console.WriteLine("{0,12}{1,-12}", " ", method.Name + " " + "<" + method.ReturnParameter.ParameterType.Name + ">");
            int count = 1;
            foreach (ParameterInfo parameter in method.GetParameters()) {
                Console.WriteLine("{0, 35}{1, -12}"," ", (count++).ToString() + " " + parameter.Name + " (" + parameter.ParameterType.Name + ")");
            }
            Console.WriteLine("{0,12}{1}", " ", dashes);
        }
    }
    private static Type targetType;
}

dynamic invocation is demonstrated with MethodInfo.Invoke and Type.InvokeMember

 
using System;
using System.Reflection;

class Starter {
    static void Main() {
        MyClass obj = new MyClass();
        Type tObj = obj.GetType();
        MethodInfo method = tObj.GetMethod("MethodA");
        method.Invoke(obj, null);
        tObj.InvokeMember("MethodA", BindingFlags.InvokeMethod,
            null, obj, null);
    }
}
class MyClass {
    public void MethodA() {
        Console.WriteLine("MyClass.Method invoked");
    }
}

Finding the class that contains a method in an assembly.

 

using System;
using System.Reflection;
using System.Collections;
class MainClass {
    public static void Main(string[] args) {
       SearchForMethod(args[0], args[1]);
    }
    public static void SearchForMethod(string AssemblyName,string MethodName) {
        Assembly assembly = Assembly.LoadFrom(AssemblyName);
        if (assembly == null) {
            Console.WriteLine(AssemblyName);
            return;
        }
        foreach (Type t in assembly.GetTypes()) {
            if (t.IsClass == false)
                continue;
            foreach (MethodInfo m in t.GetMethods()) {
                if (m.Name == MethodName) {
                    Console.WriteLine("Class {0} contains method",
                     t.FullName);
                }
            }
        }
    }
}

Invoke methods using reflection

/*
C#: The Complete Reference 
by Herbert Schildt 
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/

// Invoke methods using reflection. 
 
using System; 
using System.Reflection; 
 
class MyClass { 
  int x; 
  int y; 
 
  public MyClass(int i, int j) { 
    x = i; 
    y = j; 
  } 
 
  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); 
  } 
} 
 
public class InvokeMethDemo { 
  public static void Main() { 
    Type t = typeof(MyClass);   
    MyClass reflectOb = new MyClass(10, 20); 
    int val; 
 
    Console.WriteLine("Invoking methods in " + t.Name);     
    Console.WriteLine(); 
    MethodInfo[] mi = t.GetMethods(); 
 
    // Invoke each method. 
    foreach(MethodInfo m in mi) { 
      // Get the parameters 
      ParameterInfo[] pi = m.GetParameters(); 
 
      if(m.Name.rupareTo("set")==0 && 
         pi[0].ParameterType == typeof(int)) { 
        object[] args = new object[2]; 
        args[0] = 9; 
        args[1] = 18; 
        m.Invoke(reflectOb, args); 
      } 
      else if(m.Name.rupareTo("set")==0 && 
         pi[0].ParameterType == typeof(double)) { 
        object[] args = new object[2]; 
        args[0] = 1.12; 
        args[1] = 23.4; 
        m.Invoke(reflectOb, args); 
      } 
      else if(m.Name.rupareTo("sum")==0) { 
        val = (int) m.Invoke(reflectOb, null); 
        Console.WriteLine("sum is " + val); 
      } 
      else if(m.Name.rupareTo("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.rupareTo("show")==0) { 
        m.Invoke(reflectOb, null); 
      } 
    } 
  } 
}

List Assembly Info

 
using System;
using System.Collections;
using System.Reflection;
public class MainClass{
    public static void Main(){
        Assembly LoadedAsm = Assembly.LoadFrom("System.String");
        Console.WriteLine(LoadedAsm.FullName);
        if (LoadedAsm.GlobalAssemblyCache == true) {
            Console.WriteLine("\tThis is a Global Assembly");
        } else {
            Console.WriteLine("\tThis is a Local Assembly");
        }
        MethodInfo entry = LoadedAsm.EntryPoint;
        if (entry != null) {
            Console.WriteLine("\tAssembly EntryPoint:\t{0}", entry.Name);
        } else {
            Console.WriteLine("\tThis Assembly has no Entry point.");
        }
        object[] attrs = LoadedAsm.GetCustomAttributes(true);
        if (attrs.Length == 0) {
            Console.WriteLine("\tNo Custom Attributes Found");
        } else {
            Console.WriteLine("\tFound Attributes");
            foreach (object o in attrs) {
                Console.WriteLine("\t\t{0}", o.ToString());
            }
        }
    }
}

MethodInfo: Name

 
using System;
using System.Collections;
using System.Reflection;

public class Starter {
    public static void Main() {
        Object obj = new Object();
        Type t = obj.GetType();
        foreach (MethodInfo m in t.GetMethods()) {
            Console.WriteLine(m.Name);
        }
    }
}

Type.GetMethods

 
using System;
using System.Reflection;
public class Class1 {
    public static int Main() {
        Type t = typeof(MyClass);
        Console.WriteLine("Type of class: " + t);
        Console.WriteLine("Namespace: " + t.Namespace);
        MethodInfo[] mi = t.GetMethods();
        Console.WriteLine("Methods are:");
        foreach (MethodInfo i in mi) {
            Console.WriteLine("Name: " + i.Name);
            ParameterInfo[] pif = i.GetParameters();
            foreach (ParameterInfo p in pif) {
                Console.WriteLine("Type: " + p.ParameterType + " parameter name: " + p.Name);
            }
        }
        return 0;
    }

    public class MyClass {
        public int pubInteger;
        private int _privValue;
        public MyClass() {
        }
        public MyClass(int IntegerValueIn) {
            pubInteger = IntegerValueIn;
        }
        public int Add10(int IntegerValueIn) {
            Console.WriteLine(IntegerValueIn);
            return IntegerValueIn + 10;
        }
        public int TestProperty {
            get {
                return _privValue;
            }
            set {
                _privValue = value;
            }
        }
    }
}