silverlight根据json字符串动态创建实体类

1、接收json字符串：

//用JsonValue转换json字符串是为了之后获得json字符串的每行数据和每一列的列名

JsonValue jv = JsonValue.Parse(json);     //JsonValue引用自System.Json

2、创建两个类：一个为创建实体类方法，一个为调用实体类方法，实现操作并返回数据：

//创建实体方法类  

public class DynamicTypeBuilder

    {

        TypeBuilder tb;

        /// 


        /// 构造函数

        /// 

        /// 动态类型的名称

        public DynamicTypeBuilder(string typeNm)

        {

            // 在 Silverlight 中 AssemblyBuilderAccess 没有 RunAndSave

            AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly(

                new AssemblyName("TempAssembly"), AssemblyBuilderAccess.Run);

            ModuleBuilder mb = ab.DefineDynamicModule("TempModule");

            this.tb = mb.DefineType(typeNm, TypeAttributes.Public);

        }

        /// 


        /// 添加一个public的可读写属性，并且会创建对应的名为 propertyNm + "Field" 的私有字段

        /// 

        /// 

        /// 

        public void AppendPublicProperty(string propertyNm, Type type)

        {

            this.AppendPublicProperty(propertyNm, type, true, true);

        }

        /// 


        /// 添加一个public属性，并且会创建对应的名为 propertyNm + "Field" 的私有字段

        /// 

        /// 

        /// 

        /// 是否实现getter

        /// 是否实现setter

        public void AppendPublicProperty(string propertyNm, Type type, bool canGet, bool canSet)

        {

            string arr = string.Format("{0}Field", propertyNm);

            //FieldBuilder field = this.tb.DefineField(propertyNm, typeof(System.String), FieldAttributes.Private);

            //FieldBuilder field = this.tb.DefineField(arr, type, FieldAttributes.Private);

            FieldBuilder field = tb.DefineField("myField", typeof(System.String), FieldAttributes.Private);

            PropertyBuilder property = tb.DefineProperty(propertyNm, PropertyAttributes.HasDefault, type, null);

            MethodAttributes getSetAttr = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig;

            if (canGet)

            {

                MethodBuilder getAccessor = tb.DefineMethod(string.Format("get_{0}", propertyNm), getSetAttr, type, Type.EmptyTypes);

                ILGenerator getIL = getAccessor.GetILGenerator();

                // For an instance property, argument default is the instance. Load the

                // instance, then load the private field and return, leaving the

                // field value on the stack.

                getIL.Emit(OpCodes.Ldarg_0);

                getIL.Emit(OpCodes.Ldfld, field);

                getIL.Emit(OpCodes.Ret);

                property.SetGetMethod(getAccessor);

            }

            if (canSet)

            {

                MethodBuilder setAccessor = tb.DefineMethod(string.Format("set_{0}", propertyNm), getSetAttr, null, new Type[] { type });

                setAccessor.DefineParameter(1, ParameterAttributes.None, "value");

                ILGenerator setIL = setAccessor.GetILGenerator();

                // Load the instance and then the numeric argument, then store the

                // argument in the field.

                setIL.Emit(OpCodes.Ldarg_0);

                setIL.Emit(OpCodes.Ldarg_1);

                setIL.Emit(OpCodes.Stfld, field);

                setIL.Emit(OpCodes.Ret);

                property.SetSetMethod(setAccessor);

            }

        }

        /// 


        /// 在添加完各个 public 属性之后，调用此方法以完成对动态类型的定义并加载之，

        /// 此后通过 Activator.CreateInstance() 便可实例化动态类型

        /// 

        /// 

        public Type CreateDynamicType()

        {

            return this.tb.CreateType();

        }

        public Type DynamicCreateType()

        {

            //动态创建程序集

            AssemblyName DemoName = new AssemblyName("DynamicAssembly");

            AssemblyBuilder dynamicAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(DemoName, AssemblyBuilderAccess.Run);

            //动态创建模块

            ModuleBuilder mb = dynamicAssembly.DefineDynamicModule("TempModule");

            //动态创建类MyClass

            TypeBuilder tb = mb.DefineType("MyClass", TypeAttributes.Public);

            //动态创建字段

            FieldBuilder fb = tb.DefineField("myField", typeof(System.String), FieldAttributes.Private);

            //动态创建构造函数

            Type[] clorType = new Type[] { typeof(System.String) };

            ConstructorBuilder cb1 = tb.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, clorType);

            //生成指令

            ILGenerator ilg = cb1.GetILGenerator();//生成 Microsoft 中间语言 (MSIL) 指令

            ilg.Emit(OpCodes.Ldarg_0);

            ilg.Emit(OpCodes.Call, typeof(object).GetConstructor(Type.EmptyTypes));

            ilg.Emit(OpCodes.Ldarg_0);

            ilg.Emit(OpCodes.Ldarg_1);

            ilg.Emit(OpCodes.Stfld, fb);

            ilg.Emit(OpCodes.Ret);

            //动态创建属性

            PropertyBuilder pb = tb.DefineProperty("MyProperty", PropertyAttributes.HasDefault, typeof(string), null);

            //动态创建方法

            MethodAttributes getSetAttr = MethodAttributes.Public | MethodAttributes.SpecialName;

            MethodBuilder myMethod = tb.DefineMethod("get_Field", getSetAttr, typeof(string), Type.EmptyTypes);

            //生成指令

            ILGenerator numberGetIL = myMethod.GetILGenerator();

            numberGetIL.Emit(OpCodes.Ldarg_0);

            numberGetIL.Emit(OpCodes.Ldfld, fb);

            numberGetIL.Emit(OpCodes.Ret);

            //使用动态类创建类型

            Type classType = tb.CreateType();

            //保存动态创建的程序集 (程序集将保存在程序目录下调试时就在Debug下)

            //dynamicAssembly.Save(DemoName.Name + ".dll");

            //创建类

            return classType;

        }

//操作实体类

 

public class CreateModel
    {
        public List