1.

    class ClassHelperDemo
    {
        public static void Main()
        {
            #region 演示一：動態生成類。
            //生成一個類t。
            Type t = ClassHelper.BuildType("MyClass");
            #endregion

            #region 演示二：動態添加屬性到類。
            //先定義兩個屬性。
            List<ClassHelper.CustPropertyInfo> lcpi = new
 
 List<ClassHelper.CustPropertyInfo>();
            ClassHelper.CustPropertyInfo cpi;

            cpi = new ClassHelper.CustPropertyInfo("System.String", "Name1");
            lcpi.Add(cpi);
            cpi = new ClassHelper.CustPropertyInfo("System.String", "Name2");
            lcpi.Add(cpi);

            
 
//再加入上面定義的兩個屬性到我們生成的類t。
            t = ClassHelper.AddProperty(t, lcpi);

            //把它顯示出來。
            DispProperty(t);

            //再定義兩個屬性。
            lcpi.Clear();
            cpi = new ClassHelper.CustPropertyInfo("System.Int32", "Orther1");
            lcpi.Add(cpi);
            cpi 
 
= new ClassHelper.CustPropertyInfo("System.Int32", "Orther2");
            lcpi.Add(cpi);

            //再加入上面定義的兩個屬性到我們生成的類t。
            t = ClassHelper.AddProperty(t, lcpi);

            //再把它顯示出來，看看有沒有增加到4個屬性。
            DispProperty(t);
            #endregion

            #region 演示三：動態從類裏刪除屬性。
            //把‘S1‘屬性從類t中刪除。
            t = ClassHelper.DeleteProperty(t, "Name1");
            //顯示出來，可以看到‘S1‘不見了。
            DispProperty(t);

            #endregion

            #region 演示四：動態獲取和設置屬性值。
            //先生成一個類t的實例o。
            object o = ClassHelper.CreateInstance(t);

            //給S2,I2屬性賦值。
            ClassHelper.SetPropertyValue(o, "Name2", "abcd");
            ClassHelper.SetPropertyValue(o, "Orther2", 1234);

            //再把S2,I2的屬性值顯示出來。
            Console.WriteLine("Name2 = {0}", ClassHelper.GetPropertyValue(o, "Name2"));
            Console.WriteLine("Orther2 = {0}", ClassHelper.GetPropertyValue(o, "Orther2"));
            #endregion

            Console.Read();
            Console.ReadKey();
        }

        public static void DispProperty(Type t)
        {
            Console.WriteLine("ClassName ‘{0}‘", t.Name);
            foreach (PropertyInfo pInfo in t.GetProperties())
            {
                Console.WriteLine("Has Property ‘{0}‘", pInfo.ToString());
            }
            Console.WriteLine("");
        }
    }

2.

    class ClassHelper
    {
        #region 公有方法
        /// <summary>
        /// 根據類的類型型創建類實例。
        /// </summary>
        /// <param name="t">將要創建的類型。</param>
        /// <returns>返回創建的類實例。</returns>
        public static object CreateInstance(Type t)
        {
            return Activator.CreateInstance(t);
        }

        /// <summary>
        /// 根據類的名稱，屬性列表創建型實例。
        /// </summary>
        /// <param name="className">將要創建的類的名稱。</param>
        /// <param name="lcpi">將要創建的類的屬性列表。</param>
        /// <returns>返回創建的類實例</returns>
        public static object CreateInstance(string className, List<CustPropertyInfo> lcpi)
        {
            Type t = BuildType(className);
            t = AddProperty(t, lcpi);
            return Activator.CreateInstance(t);
        }

        /// <summary>
        /// 根據屬性列表創建類的實例，默認類名為DefaultClass，由於生成的類不是強類型，所以類名可以忽略。
        /// </summary>
        /// <param name="lcpi">將要創建的類的屬性列表</param>
        /// <returns>返回創建的類的實例。</returns>
        public static object CreateInstance(List<CustPropertyInfo> lcpi)
        {
            return CreateInstance("DefaultClass", lcpi);
        }

        /// <summary>
        /// 根據類的實例設置類的屬性。
        /// </summary>
        /// <param name="classInstance">將要設置的類的實例。</param>
        /// <param name="propertyName">將要設置屬性名。</param>
        /// <param name="propertSetValue">將要設置屬性值。</param>
        public static void SetPropertyValue(object classInstance, string propertyName, object propertSetValue)
        {
            classInstance.GetType().InvokeMember(propertyName, BindingFlags.SetProperty,
                                          null, classInstance, new object[] { Convert.ChangeType(propertSetValue, propertSetValue.GetType()) });
        }

        /// <summary>
        /// 根據類的實例獲取類的屬性。
        /// </summary>
        /// <param name="classInstance">將要獲取的類的實例</param>
        /// <param name="propertyName">將要設置的屬性名。</param>
        /// <returns>返回獲取的類的屬性。</returns>
        public static object GetPropertyValue(object classInstance, string propertyName)
        {
            return classInstance.GetType().InvokeMember(propertyName, BindingFlags.GetProperty,
                                                          null, classInstance, new object[] { });
        }

        /// <summary>
        /// 創建一個沒有成員的類型的實例，類名為"DefaultClass"。
        /// </summary>
        /// <returns>返回創建的類型的實例。</returns>
        public static Type BuildType()
        {
            return BuildType("DefaultClass");
        }

        /// <summary>
        /// 根據類名創建一個沒有成員的類型的實例。
        /// </summary>
        /// <param name="className">將要創建的類型的實例的類名。</param>
        /// <returns>返回創建的類型的實例。</returns>
        public static Type BuildType(string className)
        {

            AppDomain myDomain = Thread.GetDomain();
            AssemblyName myAsmName = new AssemblyName();
            myAsmName.Name = "MyDynamicAssembly";

            //創建一個永久程序集，設置為AssemblyBuilderAccess.RunAndSave。
            AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(myAsmName,AssemblyBuilderAccess.RunAndSave);

            //創建一個永久單模程序塊。
            ModuleBuilder myModBuilder =myAsmBuilder.DefineDynamicModule(myAsmName.Name, myAsmName.Name + ".dll");

            //創建TypeBuilder。
            TypeBuilder myTypeBuilder = myModBuilder.DefineType(className,TypeAttributes.Public);

            //創建類型。
            Type retval = myTypeBuilder.CreateType();

            //保存程序集，以便可以被Ildasm.exe解析，或被測試程序引用。
            myAsmBuilder.Save(myAsmName.Name + ".dll");
            return retval;
        }

        /// <summary>
        /// 添加屬性到類型的實例，註意：該操作會將其它成員清除掉，其功能有待完善。
        /// </summary>
        /// <param name="classType">指定類型的實例。</param>
        /// <param name="lcpi">表示屬性的一個列表。</param>
        /// <returns>返回處理過的類型的實例。</returns>
        public static Type AddProperty(Type classType, List<CustPropertyInfo> lcpi)
        {
            //合並先前的屬性，以便一起在下一步進行處理。
            MergeProperty(classType, lcpi);
            //把屬性加入到Type。
            return AddPropertyToType(classType, lcpi);
        }

        /// <summary>
        /// 添加屬性到類型的實例，註意：該操作會將其它成員清除掉，其功能有待完善。
        /// </summary>
        /// <param name="classType">指定類型的實例。</param>
        /// <param name="cpi">表示一個屬性。</param>
        /// <returns>返回處理過的類型的實例。</returns>
        public static Type AddProperty(Type classType, CustPropertyInfo cpi)
        {
            List<CustPropertyInfo> lcpi = new List<CustPropertyInfo>();
            lcpi.Add(cpi);
            //合並先前的屬性，以便一起在下一步進行處理。
            MergeProperty(classType, lcpi);
            //把屬性加入到Type。
            return AddPropertyToType(classType, lcpi);
        }

        /// <summary>
        /// 從類型的實例中移除屬性，註意：該操作會將其它成員清除掉，其功能有待完善。
        /// </summary>
        /// <param name="classType">指定類型的實例。</param>
        /// <param name="cpi">要移除的屬性。</param>
        /// <returns>返回處理過的類型的實例。</returns>
        public static Type DeleteProperty(Type classType, string propertyName)
        {
            List<string> ls = new List<string>();
            ls.Add(propertyName);

            //合並先前的屬性，以便一起在下一步進行處理。
            List<CustPropertyInfo> lcpi = SeparateProperty(classType, ls);
            //把屬性加入到Type。
            return AddPropertyToType(classType, lcpi);
        }

        /// <summary>
        /// 從類型的實例中移除屬性，註意：該操作會將其它成員清除掉，其功能有待完善。
        /// </summary>
        /// <param name="classType">指定類型的實例。</param>
        /// <param name="lcpi">要移除的屬性列表。</param>
        /// <returns>返回處理過的類型的實例。</returns>
        public static Type DeleteProperty(Type classType, List<string> ls)
        {
            //合並先前的屬性，以便一起在下一步進行處理。
            List<CustPropertyInfo> lcpi = SeparateProperty(classType, ls);
            //把屬性加入到Type。
            return AddPropertyToType(classType, lcpi);
        }
        #endregion

        #region 私有方法
        /// <summary>
        /// 把類型的實例t和lcpi參數裏的屬性進行合並。
        /// </summary>
        /// <param name="t">實例t</param>
        /// <param name="lcpi">裏面包含屬性列表的信息。</param>
        private static void MergeProperty(Type t, List<CustPropertyInfo> lcpi)
        {
            CustPropertyInfo cpi;
            foreach (PropertyInfo pi in t.GetProperties())
            {
                cpi = new CustPropertyInfo(pi.PropertyType.FullName, pi.Name);
                lcpi.Add(cpi);
            }
        }

        /// <summary>
        /// 從類型的實例t的屬性移除屬性列表lcpi，返回的新屬性列表在lcpi中。
        /// </summary>
        /// <param name="t">類型的實例t。</param>
        /// <param name="lcpi">要移除的屬性列表。</param>
        private static List<CustPropertyInfo> SeparateProperty(Type t, List<string> ls)
        {
            List<CustPropertyInfo> ret = new List<CustPropertyInfo>();
            CustPropertyInfo cpi;
            foreach (PropertyInfo pi in t.GetProperties())
            {
                foreach (string s in ls)
                {
                    if (pi.Name != s)
                    {
                        cpi = new CustPropertyInfo(pi.PropertyType.FullName, pi.Name);
                        ret.Add(cpi);
                    }
                }
            }

            return ret;
        }

        /// <summary>
        /// 把lcpi參數裏的屬性加入到myTypeBuilder中。註意：該操作會將其它成員清除掉，其功能有待完善。
        /// </summary>
        /// <param name="myTypeBuilder">類型構造器的實例。</param>
        /// <param name="lcpi">裏面包含屬性列表的信息。</param>
        private static void AddPropertyToTypeBuilder(TypeBuilder myTypeBuilder, List<CustPropertyInfo> lcpi)
        {
            FieldBuilder customerNameBldr;
            PropertyBuilder custNamePropBldr;
            MethodBuilder custNameGetPropMthdBldr;
            MethodBuilder custNameSetPropMthdBldr;
            MethodAttributes getSetAttr;
            ILGenerator custNameGetIL;
            ILGenerator custNameSetIL;

            // 屬性Set和Get方法要一個專門的屬性。這裏設置為Public。
            getSetAttr =
                MethodAttributes.Public | MethodAttributes.SpecialName |
                    MethodAttributes.HideBySig;

            // 添加屬性到myTypeBuilder。
            foreach (CustPropertyInfo cpi in lcpi)
            {
                //定義字段。
                customerNameBldr = myTypeBuilder.DefineField(cpi.FieldName,
                                                                 Type.GetType(cpi.Type),
                                                                 FieldAttributes.Private);

                //定義屬性。
                //最後一個參數為null，因為屬性沒有參數。
                custNamePropBldr = myTypeBuilder.DefineProperty(cpi.PropertyName,
                                                                 PropertyAttributes.HasDefault,
                                                                 Type.GetType(cpi.Type),
                                                                 null);


                //定義Get方法。
                custNameGetPropMthdBldr =
                    myTypeBuilder.DefineMethod(cpi.GetPropertyMethodName,
                                               getSetAttr,
                                               Type.GetType(cpi.Type),
                                               Type.EmptyTypes);

                custNameGetIL = custNameGetPropMthdBldr.GetILGenerator();

                custNameGetIL.Emit(OpCodes.Ldarg_0);
                custNameGetIL.Emit(OpCodes.Ldfld, customerNameBldr);
                custNameGetIL.Emit(OpCodes.Ret);

                //定義Set方法。
                custNameSetPropMthdBldr =
                    myTypeBuilder.DefineMethod(cpi.SetPropertyMethodName,
                                               getSetAttr,
                                               null,
                                               new Type[] { Type.GetType(cpi.Type) });

                custNameSetIL = custNameSetPropMthdBldr.GetILGenerator();

                custNameSetIL.Emit(OpCodes.Ldarg_0);
                custNameSetIL.Emit(OpCodes.Ldarg_1);
                custNameSetIL.Emit(OpCodes.Stfld, customerNameBldr);
                custNameSetIL.Emit(OpCodes.Ret);

                //把創建的兩個方法(Get,Set)加入到PropertyBuilder中。
                custNamePropBldr.SetGetMethod(custNameGetPropMthdBldr);
                custNamePropBldr.SetSetMethod(custNameSetPropMthdBldr);
            }
        }

        /// <summary>
        /// 把屬性加入到類型的實例。
        /// </summary>
        /// <param name="classType">類型的實例。</param>
        /// <param name="lcpi">要加入的屬性列表。</param>
        /// <returns>返回處理過的類型的實例。</returns>
        public static Type AddPropertyToType(Type classType, List<CustPropertyInfo> lcpi)
        {
            AppDomain myDomain = Thread.GetDomain();
            AssemblyName myAsmName = new AssemblyName();
            myAsmName.Name = "MyDynamicAssembly";

            //創建一個永久程序集，設置為AssemblyBuilderAccess.RunAndSave。
            AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(myAsmName,
                                                            AssemblyBuilderAccess.RunAndSave);

            //創建一個永久單模程序塊。
            ModuleBuilder myModBuilder =
                myAsmBuilder.DefineDynamicModule(myAsmName.Name, myAsmName.Name + ".dll");
            //創建TypeBuilder。
            TypeBuilder myTypeBuilder = myModBuilder.DefineType(classType.FullName,
                                                            TypeAttributes.Public);

            //把lcpi中定義的屬性加入到TypeBuilder。將清空其它的成員。其功能有待擴展，使其不影響其它成員。
            AddPropertyToTypeBuilder(myTypeBuilder, lcpi);

            //創建類型。
            Type retval = myTypeBuilder.CreateType();

            //保存程序集，以便可以被Ildasm.exe解析，或被測試程序引用。
            myAsmBuilder.Save(myAsmName.Name + ".dll");
            return retval;
        }
        #endregion

        #region 輔助類
        /// <summary>
        /// 自定義的屬性信息類型。
        /// </summary>
        public class CustPropertyInfo
        {
            private string propertyName;
            private string type;

            /// <summary>
            /// 空構造。
            /// </summary>
            public CustPropertyInfo() { }

            /// <summary>
            /// 根據屬性類型名稱，屬性名稱構造實例。
            /// </summary>
            /// <param name="type">屬性類型名稱。</param>
            /// <param name="propertyName">屬性名稱。</param>
            public CustPropertyInfo(string type, string propertyName)
            {
                this.type = type;
                this.propertyName = propertyName;
            }

            /// <summary>
            /// 獲取或設置屬性類型名稱。
            /// </summary>
            public string Type
            {
                get { return type; }
                set { type = value; }
            }

            /// <summary>
            /// 獲取或設置屬性名稱。
            /// </summary>
            public string PropertyName
            {
                get { return propertyName; }
                set { propertyName = value; }
            }

            /// <summary>
            /// 獲取屬性字段名稱。
            /// </summary>
            public string FieldName
            {
                get { return propertyName.Substring(0, 1).ToLower() + propertyName.Substring(1); }
            }

            /// <summary>
            /// 獲取屬性在IL中的Set方法名。
            /// </summary>
            public string SetPropertyMethodName
            {
                get { return "set_" + PropertyName; }
            }

            /// <summary>
            ///  獲取屬性在IL中的Get方法名。
            /// </summary>
            public string GetPropertyMethodName
            {
                get { return "get_" + PropertyName; }
            }
        }
        #endregion
    }

XML之自動生成類，添加，修改，刪除類的屬性