序列化后的json串与解析json串实体间的关系

Posted 2020-07-15 jiang_jiang

　　一般用一个实体去解析一个json串通常会存在以下几种情况：

　　1.序列化成json的实体属性多于解析json串的实体属性。

　　2.解析json串的实体属性多于序列化成json的实体属性。

　　3.序列化成json串的实体类与解析json串的实体类名字不一致。

　　4.序列化成json串的实体的属性跟解析json串实体属性类型不一致，但名字一致。

　　5.是否任意一个实体都可以解析json串。

　　以下是实验的例子：
　　1.序列化成json的实体属性多于解析json串的实体属性。

　　这是序列化成json的实体类型。

   public class Grade
    {
        public List<Student> TS { get; set; }
    }

  public class Student
    {
        public int StuNumber { set; get; }
        public string Phone { get; set; }
        public int ID{set;get;}
        public string Name { set; get; }
    }

　　解析json的实体：

 public class Student
    {
        public int ID{set;get;}
        public string Name { set; get; }
    }

　以下是实验的部分代码：

 static void Main(string[] args)
        {
            string Json = "{\\"TS\\":[{\\"StuNumber\\":100,\\"ID\\":0,\\"Name\\":\\"Name_0\\",\\"Phone\\":\\"15901062960\\"},{\\"StuNumber\\":101,\\"ID\\":1,\\"Name\\":\\"Name_1\\",\\"Phone\\":\\"15901062961\\"}]}";
            /* 第一步验证 json对象串的属性多于实体时，是否能够解析*/
             Grade gr0 = JsonHelper.DeserializeJsonToObject<Grade>(Json);//第一步验证
             if (gr0 != null && gr0.TS.Count > 0)
             {
                 Console.WriteLine("当json串对象多于实体时，可以正常解析成实体");
             }
 　　　　　　 Console.ReadKey(); 
        }

　　运行结果如下：

　　证明当序列化为json串的实体属性多于解析json串的实体属性的时候，是可以被正常解析的。

　　2.验证解析json串的实体属性多于序列化成json的实体属性是否可以正常被解析。

　　json串跟原来的一致，解析json串的实体比原来多了几个属性，如下：

    public class Student
    {
        public int ID{set;get;}
        public string Name { set; get; }
        public int StuNumber { set; get; }
        public string Phone { get; set; }
        public int Age { set; get; }
        public string Address { get; set; }
    }
 

　　实验的部分代码如下：

string Json = "{\\"TS\\":[{\\"StuNumber\\":100,\\"ID\\":0,\\"Name\\":\\"Name_0\\",\\"Phone\\":\\"15901062960\\"},{\\"StuNumber\\":101,\\"ID\\":1,\\"Name\\":\\"Name_1\\",\\"Phone\\":\\"15901062961\\"}]}"; 
Grade gr0 = JsonHelper.DeserializeJsonToObject<Grade>(Json);//第二步验证
            if (gr0 != null && gr0.TS.Count > 0)
            {
                if (gr0.TS[0].Address == null && gr0.TS[0].Age == 0)
                {
                    Console.WriteLine("当Json串的实体属性少于真正的实体的时候，解析出来之后，真正实体的引用类型为null,值类型为0");
                }
            }

　　运行结果如下：

　　实验证明:当序列化成json的实体属性少于真正解析这个json串的实体属性的时候，这个json串是可以被正常解析的，但是没有存在的实体引用类型属性被解析为null，值类型被解析成0.

　　3.序列化成json串的实体类与解析json串的实体类名字不一致，其实我们从json串中是反映不出原来的实体名称的，所以我们猜想是可以的，但是还是验证一下。

　　这里新添加了一个新类型，用于解析上文的json串，新的实体类型如下：

 public class GradeOther
    {
        public List<Student> TS { get; set; }
    }

　　测试代码如下：

Grade gr0 = JsonHelper.DeserializeJsonToObject<Grade>(Json);//第三步验证
            GradeOther gr1 = JsonHelper.DeserializeJsonToObject<GradeOther>(Json);
            if (gr0 != null && gr0.TS.Count > 0&&gr1!=null&&gr1.TS .Count >0)
            {
                Console.WriteLine("原实体类型与新实体类型名称不一致也没关系，也可以正常解析");
            }

　　运行结果：

　　实验证明：序列化成json串的实体类型跟解析json串的实体类型名称不一致是没有关系的，是可以正常解析的。

　　4.序列化成json串的实体的属性跟解析json串实体属性类型不一致，但名字一致。

　　首先再添加一个新的类型，改一下GradeOther实体，让其将对象解析成新的类型，看结果如何。如下是添加及修改的代码：

//添加 
  public class StudentOther
    {
        public int ID { set; get; }
        public string Name { set; get; }
    }

//修改
  public class GradeOther
    {
        public List<StudentOther> TS { get; set; }
    }

　　实验代码如下：

  Grade gr0 = JsonHelper.DeserializeJsonToObject<Grade>(Json);//第四步验证
            GradeOther gr1 = JsonHelper.DeserializeJsonToObject<GradeOther>(Json);
            if (gr0 != null && gr0.TS.Count > 0&&gr1!=null&&gr1.TS .Count >0)
            {
                Console.WriteLine("原实体的属性的类型与新实体类型不一致也没关系，也可以正常解析");
            }

　　实验证明：序列化成json串的实体的属性跟解析json串实体属性类型不一致，但名字一致也可以正常解析。

　　5.以上的种种证明给我们一种，任何一个实体都可以解析json串，只不过有的可以解析出来值而有的为空而已，应该都不会报错。但是事实是这样吗？我们来验证下是否是所有的类型都可以解析json串。

　　在这里json串我们还用之前的json串，我们添加了一个新的实体类型去解析这个json串。

 public class GradeTemp
    {
        public List<string> TS { get; set; }
    }

　　实验代码如下：

try
            {
                GradeTemp gt = JsonHelper.DeserializeJsonToObject<GradeTemp>(Json);
                if (gt != null)
                {
                    Console.WriteLine("任意实体都可以解析JSON");
                    if (gt.TS != null)
                    {
                        Console.WriteLine("解析JSON的过程中不判断字段类型，只看名称");
                    }
                }

                else
                {
                    Console.WriteLine("并非所有的实体都可以解析JSON");
                }
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex.Message .ToString ());
                Console.WriteLine("当属性的类型与原来相同名字字段类型有冲突时会报错");
               
            }

　　实验结果如下：

　　实验证明：并非任何一个实体都可以解析json串，当属性名称相同，但类型互不兼容时会出错。

　　结论：

　　解析json的实体属性与序列化成json串的实体属性多少并不影响正常的解析（指的是不会报错，对应的属性可以解析成功），但是如果两个实体名称相同的属性类型不一致时，如果可以互相兼容（A类与B类属性多少并没关系，主要是对应的属性能否转换），也是没问题的，如果不能兼容，那么解析是会报错的。

　　源代码地址：https://yunpan.cn/cStbTkMNS4pSV  访问密码 6f08

　　如果有不妥之处，欢迎大家批评指正。