reflect practice

using System;
using System.Reflection;
using System.Text;
using System.Runtime.Remoting;
using System.Globalization;

public interface WriteClass
{
    void write(string string1);
}
public class InterfaceTest : WriteClass
{
    #region WriteClass Members

    public void write(string string1)
    {
        Console.WriteLine("InterfaceTest implement write:" + string1);
    }

    #endregion
}
public class SomeTypeTest : WriteClass
{

    private string _fieldString = string.Empty;

    private SomeTypeTest()
    {
    }

    private SomeTypeTest(string test)
    {
        _fieldString = test;
    }

    public string PropertyString
    {
        get;
        set;
    }

    public string ReadonlyProperty
    {
        get { return _fieldString; }
    }

    public static void DoSomethingWithStatic()
    {
        Console.WriteLine("Public method DoSomethingWithStatic ");
    }
    public void DoSomethingWithPublic(string test)
    {
        Console.WriteLine("Public method DoSomethingWithPublic write:" + test);
    }

    private void DoSomethingWithPrivate(string test)
    {
        Console.WriteLine("private method DoSomethingWithPrivate write:" + test);
    }

    public void DosomethingWithField()
    {
        Console.WriteLine("DosomethingWithField write:" + _fieldString);
    }

    #region WriteClass Members

    public void write(string string1)
    {
        Console.WriteLine("SomeTypeTest implement interface:" + string1);
    }

    #endregion
}


public class TestReflection
{
    delegate void TestDelegate(string value);
    static void Main()
    {
        //create instance of SomeTypeTest class
        ConstructorInfo ci = typeof(SomeTypeTest).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, System.Type.EmptyTypes, null);
        object doSomeInstance = ci.Invoke(System.Type.EmptyTypes);
        MethodInfo DoSomethingWithPublic = typeof(SomeTypeTest).GetMethod("DoSomethingWithPublic");
        MethodInfo DoSomethingWithPrivate = typeof(SomeTypeTest).GetMethod("DoSomethingWithPrivate", BindingFlags.NonPublic | BindingFlags.Instance);
        // Call an instance method defined by the SomeType type using this object.
        DoSomethingWithPublic.Invoke(doSomeInstance, new object[] { "public hello" });
        DoSomethingWithPrivate.Invoke(doSomeInstance, new object[] { "private hello" });

        ConstructorInfo ciWithParameter = typeof(SomeTypeTest).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] { typeof(string) }, null);
        object doSomeInstanceWithParamter = ciWithParameter.Invoke(new object[] { "test" });

        MethodInfo DosomethingWithField = typeof(SomeTypeTest).GetMethod("DosomethingWithField");
        DosomethingWithField.Invoke(doSomeInstanceWithParamter, System.Type.EmptyTypes);

        DosomethingWithField = typeof(SomeTypeTest).GetMethod("DoSomethingWithStatic");
        DosomethingWithField.Invoke(null, null);

        PropertyInfo property = typeof(SomeTypeTest).GetProperty("PropertyString");
        property.SetValue(doSomeInstance, "testProperty", null);
        Console.WriteLine(property.GetValue(doSomeInstance, null));

        PropertyInfo property2 = typeof(SomeTypeTest).GetProperty("ReadonlyProperty");
        Console.WriteLine(property.GetValue(doSomeInstanceWithParamter, null));

        FieldInfo field = typeof(SomeTypeTest).GetField("_fieldString", BindingFlags.Instance | BindingFlags.NonPublic);
        Console.WriteLine(field.GetValue(doSomeInstanceWithParamter));

        object objectHandle = Activator.CreateInstance(typeof(SomeTypeTest), BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, new object[] { "test" }, CultureInfo.CurrentCulture);
        SomeTypeTest st = (SomeTypeTest)objectHandle;
        st.DosomethingWithField();
        Console.WriteLine(st.ReadonlyProperty);

        //test delegate
        TestDelegate method = (TestDelegate)Delegate.CreateDelegate(typeof(TestDelegate), doSomeInstance, "DoSomethingWithPublic");
        method("Test Delegate");

        WriteClass writeClass = (WriteClass)Activator.CreateInstance(typeof(InterfaceTest), BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, null, CultureInfo.CurrentCulture);
        writeClass.write("WriteClass");
        st.write("WriteClass");
        Console.ReadLine();
    }
}