Csharp/CSharp Tutorial/Reflection/Method

Call string method with reflection and Expression

using System;
using System.ruponentModel;
using System.Linq.Expressions;
using System.Reflection;
    class MainClass
    {
        static void Main()
        {
            MethodInfo method = typeof(string).GetMethod("StartsWith", new[] { typeof(string) });
            var target = Expression.Parameter(typeof(string), "x");
            var methodArg = Expression.Parameter(typeof(string), "y");
            Expression[] methodArgs = new[] { methodArg };
            Expression call = Expression.Call(target, method, methodArgs);
            var lambdaParameters = new[] { target, methodArg };
            var lambda = Expression.Lambda<Func<string, string, bool>>(call, lambdaParameters);
            var compiled = lambda.rupile();
            Console.WriteLine(compiled("First", "S"));
        }
    }

Deeper Reflection: Invoking Functions

using System;
using System.Reflection;
class MainClass
{
    public static void Main(String[] args)
    {
        string aname = "MyClass";
        
        Console.WriteLine("Loading: {0}", aname);
        Assembly a = Assembly.LoadFrom (aname);
        
        foreach (Type t in a.GetTypes())
        {
            if (t.IsClass)
            {
                Console.WriteLine("  Found Class: {0}", t.FullName);
                
                if (t.GetInterface("MyInterface") == null)
                    continue;
                
                object o = Activator.CreateInstance(t);
                
                Console.WriteLine("    Calling Process() on {0}", t.FullName);
            }
        }
    }
}
//File: MyClass.cs
interface MyInterface{
  void MyMethod(int i);
}
class MyClass: MyInterface{
   public void MyMethod(int i){
      Console.WriteLine("i:"+i);
   }
}

Deeper Reflection: iterate through the methods of the class

using System;
using System.Reflection;
class MyClass
{
    MyClass() {}
    static void Process()
    {
    }
    
    public int MyFunction(int i, Decimal d, string[] args)
    {
        return(0);
    }
    public int        value = 0;
    public float        log = 1.0f;
    public static int    value2 = 44;
}
class MainClass
{    
    public static void Main(String[] args)
    {
        Console.WriteLine("Fields of MyClass");
        Type t = typeof (MyClass);
        
        Console.WriteLine("Methods of MyClass");
        foreach (MethodInfo m in t.GetMethods())
        {
            Console.WriteLine("{0}", m);
            foreach (ParameterInfo p in m.GetParameters())
            {
                Console.WriteLine("  Param: {0} {1}",
                p.ParameterType, p.Name);
            }
        }
        
    }
}

Fields of MyClass
Methods of MyClass
Int32 MyFunction(Int32, System.Decimal, System.String[])
  Param: System.Int32 i
  Param: System.Decimal d
  Param: System.String[] args
System.Type GetType()
System.String ToString()
Boolean Equals(System.Object)
  Param: System.Object obj
Int32 GetHashCode()

Dynamically Invoking A Method

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
    public class Tester
    {
        public static void Main()
        {
            Type theMathType = Type.GetType("System.Math");
            Type[] paramTypes = new Type[1];
            paramTypes[0] = Type.GetType("System.Double");
            MethodInfo CosineInfo = theMathType.GetMethod("Cos", paramTypes);
            Object[] parameters = new Object[1];
            parameters[0] = 45 * (Math.PI / 180); 
            Object returnVal = CosineInfo.Invoke(theMathType, parameters);
            Console.WriteLine(returnVal);
        }
    }

Finding Particular Members

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text;

    public class Tester
    {
        public static void Main()
        {
            Type theType = Type.GetType("System.Reflection.Assembly");
            MemberInfo[] mbrInfoArray = theType.FindMembers(
                                MemberTypes.Method,
                                BindingFlags.Public |
                                BindingFlags.Static |
                                BindingFlags.NonPublic |
                                BindingFlags.Instance |
                                BindingFlags.DeclaredOnly,
                                Type.FilterName, "Get*");
            foreach (MemberInfo mbrInfo in mbrInfoArray)
            {
                Console.WriteLine("{0} is a {1}",
                                mbrInfo, mbrInfo.MemberType);
            }
        }
    }

Inspecting a method"s body

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;
public class MainClass
{
    public static void Main()
    {
        MethodInfo m = typeof(object).GetMethod("ToString");
        MethodBody mb = m.GetMethodBody();
        byte[] ilb = mb.GetILAsByteArray();
        for (int i = 0; i < ilb.Length; i++)
            Console.Write("{0:X} ", ilb[i]);
    }
}

2 28 9 0 0 6 6F 2 0 0 6 2A

Invoke member method with created instance from reflection

using System;
using System.Reflection;
using System.Globalization;
  class Class1
  {
    DateTime[] dateTimes = new DateTime[10];
    public DateTime this[int index]
    {
      get{ return dateTimes[index]; }
      set{ dateTimes[index] = value;}
    }
    
    
    private DateTime dateOfBirth;
    public DateTime DateOfBirth
    {
        get{ return dateOfBirth; }
        set{ dateOfBirth = value; }
    }
      
    public void Test()
    {
      Console.WriteLine("Test method called");
    }
    
    
    private string field;
    
    public string Property
    { 
      get{ return field; }
      set{ field = value; }
    }
    
  }

    class MainClass{
    
    static void Main(string[] args)
    {
      Type type = Type.GetType("Class1");
      object o = Activator.CreateInstance(type);
      
      type.InvokeMember("Test", BindingFlags.InvokeMethod,null, o, new object[]{});
      
      // Using a ConstructorInfo
      ConstructorInfo constructorInfo = type.GetConstructor(new Type[]{});
        
      o = constructorInfo.Invoke(new object[]{});
      
      type.InvokeMember("Test", BindingFlags.InvokeMethod,null, o, new object[]{});
      
      // Type.InvokeMember
      o = type.InvokeMember("Class1", BindingFlags.CreateInstance, null, null, new object[]{});
      
      type.InvokeMember("Test", BindingFlags.InvokeMethod,null, o, new object[]{});
    }
    }

Invoke methods using reflection

using System; 
using System.Reflection; 
 
class MyClass { 
 
  public MyClass(int i, int j) { 
    Console.WriteLine("MyClass(int i, int j)");
    Console.WriteLine(i);
    Console.WriteLine(j);
  } 
 
  public int sum() { 
    Console.WriteLine("sum");
    return 0; 
  } 
 
  public bool isBetween(int i) { 
    Console.WriteLine("isBetween");
    return false; 
  } 
 
  public void set(int a, int b) { 
    Console.Write("Inside set(int, int). "); 
  } 
 
  public void set(double a, double b) { 
    Console.Write("Inside set(double, double). "); 
  } 
 
  public void show() { 
    Console.WriteLine("show"); 
  } 
} 
 
class MainClass { 
  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); 
      } 
    } 
  } 
}

MyClass(int i, int j)
10
20
Invoking methods in MyClass
sum
sum is 0
isBetween
Inside set(int, int). Inside set(double, double). show

List Methods

using System;
using System.Reflection;
public interface IFaceOne
{
  void MethodA();
}
public interface IFaceTwo
{
  void MethodB();
}
public class MyClass: IFaceOne, IFaceTwo
{
  public enum MyNestedEnum{}
  
  public int myIntField;
  public string myStringField;
  public void myMethod(int p1, string p2)
  {
  }
  public int MyProp
  {
    get { return myIntField; }
    set { myIntField = value; }
  }
  void IFaceOne.MethodA(){}
  void IFaceTwo.MethodB(){}
}
public class MainClass
{
  public static void Main(string[] args)
  {
    MyClass f = new MyClass();
    Type t = f.GetType();
    MethodInfo[] mi = t.GetMethods();
    foreach(MethodInfo m in mi)
      Console.WriteLine("Method: {0}", m.Name);
    
  }
}

Method: myMethod
Method: get_MyProp
Method: set_MyProp
Method: GetType
Method: ToString
Method: Equals
Method: GetHashCode

Obtain the metadata tokens

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;
public class MainClass
{
    public static void Main()
    {
        Type typeInfo = typeof(object);
        MethodInfo methInfo = typeInfo.GetMethod("ToString");
        ModuleHandle moduleHandle = methInfo.Module.ModuleHandle;
        int typeToken = typeInfo.MetadataToken;
        int methToken = methInfo.MetadataToken;
        Console.WriteLine("Token: {0}", methToken);
    }
}

Token: 100663298