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

1、接收json字符串：

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

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

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

//创建实体方法类

public class DynamicTypeBuilder

    {

        TypeBuilder tb;

        /// <summary>

        /// 构造函数

        /// </summary>

        /// <param name="typeNm">动态类型的名称</param>

        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);

        }

        /// <summary>

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

        /// </summary>

        /// <param name="propertyNm"></param>

        /// <param name="type"></param>

        public void AppendPublicProperty(string propertyNm, Type type)

        {

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

        }

        /// <summary>

        /// 加入一个public属性。而且会创建相应的名为 propertyNm + "Field" 的私有字段

        /// </summary>

        /// <param name="propertyNm"></param>

        /// <param name="type"></param>

        /// <param name="canGet">是否实现getter</param>

        /// <param name="canSet">是否实现setter</param>

        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);

            }

        }

        /// <summary>

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

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

        /// </summary>

        /// <returns></returns>

        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<Object> GetList(JsonValue colInfos)
        {
            //构造绑定DataGrid ItemSource的集合
            List<Object> list = new List<object>();
            DynamicTypeBuilder dyClass = new DynamicTypeBuilder("dy");//创建动态类，dy能够随便替换
            ////ColInfos为已经取到的列信息集合
            foreach (JsonValue v in colInfos)
            {
                //获取全部列名
                ICollection<string> col = (((System.Json.JsonObject)(v))).Keys;
                foreach (string columnName in col)
                {
                    dyClass.AppendPublicProperty(columnName, typeof(string));
                }
            }
            Type dyType = dyClass.CreateDynamicType();//创建自己定义类
            foreach (JsonValue v in colInfos)//循环行
            {
                ICollection<string> col = ((System.Json.JsonObject)(v)).Keys;
                JsonObject row = (System.Json.JsonObject)(v);
                var po = Activator.CreateInstance(dyType);//创建自己定义类实例
                foreach (var columnName in row)//循环列
                {//col
                    PropertyInfo property = dyType.GetProperty(columnName.Key);
                    if (columnName.Value == null)
                        property.SetValue(po, "", null);
                    else
                        property.SetValue(po, columnName.Value.ToString().Replace("\"", ""), null);
                }
                list.Add(po);
            }
            return list;
        }
    }

3、依据第一步创建的JsonValue 对象调用操作实体类：

                CreateModel create = new CreateModel();

                JsonValue jv = JsonValue.Parse(json);

                List<Object> li = create.GetList(jv);