精华内容
参与话题
问答
  • Newtonsoft

    2019-04-09 09:44:53
    Newtonsoft官方下载地址:https://www.newtonsoft.com/json Newtonsoft官方下载地址:https://github.com/JamesNK/Newtonsoft.Json/releases
  • NewtonSoft

    2021-01-02 16:02:27
    <div><p>The upgrade package does not include the newtonsoft.json.dll library which causes the upgrade to break if you do not already have v10.0.0.0 installed of the lib. The main install package ...
  • newtonsoft

    2019-10-01 14:58:33
    NewtonSoft只能操作public属性(原则上C#编程中不定义public的字段,所以不说字段) <2>Json字符串若提供类中没有的属性,反序列化时会忽视之,并不抛出异常 <3>反序列化的过程: 调用无参构造函数,...

    序列化和反序列化的规则

    <1>NewtonSoft只能操作public属性(原则上C#编程中不定义public的字段,所以不说字段)

    <2>Json字符串若提供类中没有的属性,反序列化时会忽视之,并不抛出异常

    <3>反序列化的过程:

    调用无参构造函数,new出一个实例,然后使用Json字符串中包含的字段or属性为成员赋值,Json字符串未提供的字段or属性的值是无参构造函数初始化的值或是0,false,null;private的字段or属性会用默认值或无参构造函数去初始化。若类未提供无参构造函数,则调用有参构造函数,但是要保证类仅有一个有参构造函数,多个有参构造函数时,若不指定哪个构造函数来反序列化,编译器会报错。所以,尽可能的为会进行序列化和反序列化的类提供无参构造函数。

    class Person
    {
        private string name;
        public string Name { get => name; set => name = value; }
    
        //年龄
        private int age;
        public int Age { get => age; set => age = value; }
    
        //城市
        public string City { get; set; }
    
        //技能
        public List<string> languages;
    
        public Person()
        {
            Name = "Andrew Magic";
            Age = 20;
            City = "Zhuhai";
            languages = new List<string>();
        }
    }

    序列化一个对象

    Person p1 = new Person();
    string p1JsonStr = JsonConvert.SerializeObject(p1);

    反序列化一个对象

    string p2JsonStr = "{\"Name\":\"Jack\" }";
    Person p2 = JsonConvert.DeserializeObject<Person>(p2JsonStr);

    序列化多个对象

    Person p3 = new Person();
    p3.Name = "LiMing";
    p3.Age = 22;
    p3.City = "Shanghai";
    p3.languages.AddRange(new string[] { "C", "Java", "PHP" });
    
    Person p4 = new Person();
    p4.Name = "ZhangSan";
    p4.Age = 20;
    p4.City = "Beijing";
    p4.languages.AddRange(new string[] { "C#", "Python", "Go" });
    
    List<Person> list = new List<Person> { p3, p4 };
    string objectsJsonStr = JsonConvert.SerializeObject(list);

    反序列化多个对象

    List<Person> list = JsonConvert.DeserializeObject<List<Person>>(objectsJsonStr);
    foreach (Person item in list)
    {
        Console.WriteLine(item.Name);
    }

     

    转载于:https://www.cnblogs.com/zhenguan/p/11309741.html

    展开全文
  • Newtonsoft.Json

    2018-05-14 17:42:39
    Newtonsoft.Json.dll Newtonsoft.Json.xml ................
  • Newtonsoft.json.compact

    2020-10-17 16:11:18
    内含Newtonsoft.json 12.0.3源码,NewtonSoft.json.compact 2.0源码(需要自己生成dll)以及NewtonSoft.json.compact.dll 3.5
  • <div><p>I have a little problem - big solution, with references to Newtonsoft Json 9 version And I want to use your library But reference to Newtonsoft version of 11 breaks my project After review ...
  • Remove newtonsoft filter

    2020-12-09 09:10:23
    <div><ul><li>Remove newtonsoft filter project</li><li>Updated code to use reflection to look for newtonsoft attributes</li><li>Corresponding test file updates</li></ul>该提问来源于开源项目:...
  • Newtonsoft.Json.rar

    2020-09-04 16:58:26
    使用NewtonSoft.JSON.dll来序列化和发序列化对象 Newtonsoft.Json 支持.net 2.0 3.5 4.0. 4.5
  • Newtonsoft.Json 扩展方法

    2020-10-17 17:52:41
    使用Newtonsoft.Json的一些扩展方法 方便对Json数据的处理 提供编码效率 让Newtonsoft.Json变得更好用
  • Newtonsoft .net framwork

    2013-02-18 15:02:53
    Newtonsoft .net framwork 3.5 ,Newtonsoft .net framwork 4.0
  • Newtonsoft.Json2.0

    2019-02-21 09:37:37
    Newtonsoft.Json.dll仅支持.Net Framework 2.0 用于json字符串解析
  • Newtonsoft.Json.dll

    2020-03-26 14:50:03
    Newtonsoft.Json.dll免费版文件是电脑中一个非常重要的文件。Newtonsoft.Json.dll免费版可以对json对象格式转化,提供最新版本Newtonsoft.Json.dll,用来解析json字符串很方便。更重要的是,它能解析二维数组!现在...
  • Newtonsoft not found

    2020-12-25 18:02:49
    <div><p>in <code>UnityMessageManager</code> it does not find <code>Newtonsoft.JSON</code></p> <p>how to add this properly?</p><p>该提问来源于开源项目:f111fei/react-native-unity-view</p></div>
  • ILRepack Newtonsoft.Net

    2020-12-31 11:51:36
    <p>But we have one small trouble using your library - Newtonsoft.Json dependency. Our code base depends on 6.0.8 version and it's very difficult to update it to latest. <p>What do you think about ...
  • Exception on Newtonsoft

    2020-12-26 19:12:36
    As openspan itself uses Newtonsoft 5.X it does not allow 10.X. We dont have any option to provide binding redirect as there is no straight way to add config file in openspan. Please suggest <p>Source...
  • Newtonsoft.Json11.0.1

    2018-03-20 13:50:30
    json对象格式转化,最新版本 Newtonsoft.Json.dll 11.0.1内含多个版本
  • Newtonsoft.Json Json.NET - Newtonsoft

    千次阅读 2019-02-22 15:55:38
    在接口多次修改中,实体添加了很多字段用于中间计算或者存储,然后最终用Newtonsoft.Json进行序列化返回数据,经过分析一个简单的列表接口每一行数据返回了16个字段,但是手机APP端只用到了其中7个字段,剩余9个字段...

    手机端应用讲究速度快,体验好。刚好手头上的一个项目服务端接口有性能问题,需要进行优化。在接口多次修改中,实体添加了很多字段用于中间计算或者存储,然后最终用Newtonsoft.Json进行序列化返回数据,经过分析一个简单的列表接口每一行数据返回了16个字段,但是手机APP端只用到了其中7个字段,剩余9个字段的数据全部都是多余的,如果接口返回数据为40K大小,也就是说大约20K的数据为无效数据,3G网络下20K下载差不多需要1s,不返回无效数据至少可以节约1s的时间,大大提高用户体验。本篇将为大家介绍Newtonsoft.Json的一些高级用法,可以修改很少的代码解决上述问题。

    阅读目录

    回到顶部

    Newtonsoft.Json介绍

      在做开发的时候,很多数据交换都是以json格式传输的。而使用Json的时候,我们很多时候会涉及到几个序列化对象的使用:DataContractJsonSerializer,JavaScriptSerializer  Json.NETNewtonsoft.Json。大多数人都会选择性能以及通用性较好Json.NET,这个不是微软的类库,但是一个开源的世界级的Json操作类库,从下面的性能对比就可以看到它的其中之一的性能优点。

    https://images0.cnblogs.com/i/8867/201404/282228152051648.png

    齐全的API介绍,使用方式简单

    https://images0.cnblogs.com/blog2015/336693/201506/281434460338410.png

     

    回到顶部

    基本用法

      Json.Net是支持序列化和反序列化DataTable,DataSet,Entity FrameworkEntity的。下面分别举例说明序列化和反序列化。

    DataTable

                //序列化DataTable
                DataTable dt = new DataTable();
                dt.Columns.Add("Age", Type.GetType("System.Int32"));
                dt.Columns.Add("Name", Type.GetType("System.String"));
                dt.Columns.Add("Sex", Type.GetType("System.String"));
                dt.Columns.Add("IsMarry", Type.GetType("System.Boolean"));
                for (int i = 0; i < 4; i++)
                {
                    DataRow dr = dt.NewRow();
                    dr["Age"] = i + 1;
                    dr["Name"] = "Name" + i;
                    dr["Sex"] = i % 2 == 0 ? "男" : "女";
                    dr["IsMarry"] = i % 2 > 0 ? true : false;
                    dt.Rows.Add(dr);
                }
                Console.WriteLine(JsonConvert.SerializeObject(dt));

    https://images0.cnblogs.com/blog2015/336693/201506/281443553617087.png

    利用上面字符串进行反序列化

     string json = JsonConvert.SerializeObject(dt);
     dt=JsonConvert.DeserializeObject<DataTable>(json);
     foreach (DataRow dr in dt.Rows)
     {
       Console.WriteLine("{0}\t{1}\t{2}\t{3}\t", dr[0], dr[1], dr[2], dr[3]);
     }

    https://images0.cnblogs.com/blog2015/336693/201506/281448403619018.png

    Entity序列化和DataTable一样,就不过多介绍了。

    回到顶部

    高级用法

        1.忽略某些属性

        2.默认值的处理

        3.空值的处理

        4.支持非公共成员

        5.日期处理

        6.自定义序列化的字段名称

      7.动态决定属性是否序列化

        8.枚举值的自定义格式化问题

      9.自定义类型转换

      10.全局序列化设置

     .忽略某些属性

      类似本问开头介绍的接口优化,实体中有些属性不需要序列化返回,可以使用该特性。首先介绍Json.Net序列化的模式:OptOut OptIn

    OptOut

    默认值,类中所有公有成员会被序列化,如果不想被序列化,可以用特性JsonIgnore

    OptIn

    默认情况下,所有的成员不会被序列化,类中的成员只有标有特性JsonProperty的才会被序列化,当类的成员很多,但客户端仅仅需要一部分数据时,很有用

     

     

     仅需要姓名属性

        [JsonObject(MemberSerialization.OptIn)]
        public class Person
        {
            public int Age { get; set; }
    
     
            [JsonProperty]
            public string Name { get; set; }
    
     
            public string Sex { get; set; }
    
     
            public bool IsMarry { get; set; }
    
     
            public DateTime Birthday { get; set; }
        }

    https://images0.cnblogs.com/blog2015/336693/201506/281508379087828.png

      不需要是否结婚属性

        [JsonObject(MemberSerialization.OptOut)]
        public class Person
        {
            public int Age { get; set; }
    
     
            public string Name { get; set; }
    
     
            public string Sex { get; set; }
    
     
            [JsonIgnore]
            public bool IsMarry { get; set; }
    
     
            public DateTime Birthday { get; set; }
        }

    https://images0.cnblogs.com/blog2015/336693/201506/281510410171151.png

      通过上面的例子可以看到,要实现不返回某些属性的需求很简单。1.在实体类上加上[JsonObject(MemberSerialization.OptOut)] 2.在不需要返回的属性上加上 [JsonIgnore]说明。

    .默认值处理

        序列化时想忽略默认值属性可以通过JsonSerializerSettings.DefaultValueHandling来确定,该值为枚举值

    DefaultValueHandling.Ignore

    序列化和反序列化时,忽略默认值

    DefaultValueHandling.Include

    序列化和反序列化时,包含默认值

     

     

     

     [DefaultValue(10)]
     public int Age { get; set; }
     Person p = new Person { Age = 10, Name = "张三丰", Sex = "男", IsMarry = false, Birthday = new DateTime(1991, 1, 2) };
     JsonSerializerSettings jsetting=new JsonSerializerSettings();
     jsetting.DefaultValueHandling=DefaultValueHandling.Ignore;
     Console.WriteLine(JsonConvert.SerializeObject(p, Formatting.Indented, jsetting));

    最终结果如下:

    https://images0.cnblogs.com/blog2015/336693/201506/290700436652801.png

     

    .空值的处理

      序列化时需要忽略值为NULL的属性,可以通过JsonSerializerSettings.NullValueHandling来确定,另外通过JsonSerializerSettings设置属性是对序列化过程中所有属性生效的,想单独对某一个属性生效可以使用JsonProperty,下面将分别展示两个方式

      1.JsonSerializerSettings

     Person p = new Person { room=null,Age = 10, Name = "张三丰", Sex = "男", IsMarry = false, Birthday = new DateTime(1991, 1, 2) };
     JsonSerializerSettings jsetting=new JsonSerializerSettings();
     jsetting.NullValueHandling = NullValueHandling.Ignore;
     Console.WriteLine(JsonConvert.SerializeObject(p, Formatting.Indented, jsetting));

       https://images0.cnblogs.com/blog2015/336693/201506/290707560092150.png

       2.JsonProperty

    https://images0.cnblogs.com/blog2015/336693/201506/290710397909914.png

    通过JsonProperty属性设置的方法,可以实现某一属性特别处理的需求,如默认值处理,空值处理,自定义属性名处理,格式化处理。上面空值处理实现

     [JsonProperty(NullValueHandling=NullValueHandling.Ignore)]
     public Room room { get; set; }

     

    .支持非公共成员

      序列化时默认都是处理公共成员,如果需要处理非公共成员,就要在该成员上加特性"JsonProperty"

     [JsonProperty]
     private int Height { get; set; }

     

    .日期处理

      对于Dateime类型日期的格式化就比较麻烦了,系统自带的会格式化成iso日期标准https://images0.cnblogs.com/blog2015/336693/201506/290743047903040.png,但是实际使用过程中大多数使用的可能是yyyy-MM-dd 或者yyyy-MM-dd HH:mm:ss两种格式的日期,解决办法是可以将DateTime类型改成string类型自己格式化好,然后在序列化。如果不想修改代码,可以采用下面方案实现。

          Json.Net提供了IsoDateTimeConverter日期转换这个类,可以通过JsnConverter实现相应的日期转换

        [JsonConverter(typeof(IsoDateTimeConverter))]
        public DateTime Birthday { get; set; }

      但是IsoDateTimeConverter日期格式不是我们想要的,我们可以继承该类实现自己的日期

        public class ChinaDateTimeConverter : DateTimeConverterBase
        {
            private static IsoDateTimeConverter dtConverter = new IsoDateTimeConverter { DateTimeFormat = "yyyy-MM-dd" };
    
     
            public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
            {
                return dtConverter.ReadJson(reader, objectType, existingValue, serializer);
            }
    
     
            public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
            {
                dtConverter.WriteJson(writer, value, serializer);
            }
        }

        自己实现了一个yyyy-MM-dd格式化转换类,可以看到只是初始化IsoDateTimeConverter时给的日期格式为yyyy-MM-dd即可,下面看下效果

    [JsonConverter(typeof(ChinaDateTimeConverter))]
    public DateTime Birthday { get; set; }

    https://images0.cnblogs.com/blog2015/336693/201506/290750116036578.png

       可以根据自己需求实现不同的转换类

     

    .自定义序列化的字段名称

        实体中定义的属性名可能不是自己想要的名称,但是又不能更改实体定义,这个时候可以自定义序列化字段名称。

         [JsonProperty(PropertyName = "CName")]
         public string Name { get; set; }

     

    .动态决定属性是否序列化

      这个是为了实现@米粒儿提的需求特别增加的,根据某些场景,可能A场景输出ABC三个属性,B场景输出EF属性。虽然实际中不一定存在这种需求,但是json.net依然可以支持该特性。

      继承默认的DefaultContractResolver类,传入需要输出的属性

         重写修改了一下,大多数情况下应该是要排除的字段少于要保留的字段,  为了方便书写这里修改了构造函数加入retain表示props是需要保留的字段还是要排除的字段

    public class LimitPropsContractResolver : DefaultContractResolver
        {
            string[] props = null;
    
     
            bool retain;
    
     
            /// <summary>
            /// 构造函数
            /// </summary>
            /// <param name="props">传入的属性数组</param>
            /// <param name="retain">true:表示props是需要保留的字段  false:表示props是要排除的字段</param>
            public LimitPropsContractResolver(string[] props, bool retain=true)
            {
                //指定要序列化属性的清单
                this.props = props;
    
     
                this.retain = retain;
            }
    
     
            protected override IList<JsonProperty> CreateProperties(Type type,
    
     
            MemberSerialization memberSerialization)
            {
                IList<JsonProperty> list =
                base.CreateProperties(type, memberSerialization);
                //只保留清单有列出的属性
                return list.Where(p => {
                    if (retain)
                    {
                        return props.Contains(p.PropertyName);
                    }
                    else
                    {
                        return !props.Contains(p.PropertyName);
                    }      
                }).ToList();
            }
        

            public int Age { get; set; }
    
     
            [JsonIgnore]
            public bool IsMarry { get; set; }
    
     
            public string Sex { get; set; }
          JsonSerializerSettings jsetting=new JsonSerializerSettings();
          jsetting.ContractResolver = new LimitPropsContractResolver(new string[] { "Age", "IsMarry" });
          Console.WriteLine(JsonConvert.SerializeObject(p, Formatting.Indented, jsetting));

      使用自定义的解析类,只输出"Age", "IsMarry"两个属性,看下最终结果.只输出了Age属性,为什么IsMarry属性没有输出呢,因为标注了JsonIgnore

     https://images0.cnblogs.com/blog2015/336693/201506/292128345097430.png

     看到上面的结果想要实现pc端序列化一部分,手机端序列化另一部分就很简单了吧,我们改下代码实现一下

      string[] propNames = null;
      if (p.Age > 10)
      {
        propNames = new string[] { "Age", "IsMarry" };
      }
      else
      {
          propNames = new string[] { "Age", "Sex" };
      }
      jsetting.ContractResolver = new LimitPropsContractResolver(propNames);
      Console.WriteLine(JsonConvert.SerializeObject(p, Formatting.Indented, jsetting));

     

    .枚举值的自定义格式化问题

      默认情况下对于实体里面的枚举类型系统是格式化成改枚举对应的整型数值,那如果需要格式化成枚举对应的字符怎么处理呢?Newtonsoft.Json也帮我们想到了这点,下面看实例

        public enum NotifyType
        {
            /// <summary>
            /// Emil发送
            /// </summary>
            Mail=0,
    
     
            /// <summary>
            /// 短信发送
            /// </summary>
            SMS=1
        }
    
     
        public class TestEnmu
        {
            /// <summary>
            /// 消息发送类型
            /// </summary>
            public NotifyType Type { get; set; }
        }
        JsonConvert.SerializeObject(new TestEnmu());

    输出结果:https://images2015.cnblogs.com/blog/336693/201509/336693-20150910171743028-388882267.png  现在改造一下,输出"Type":"Mail"

        public class TestEnmu
        {
            /// <summary>
            /// 消息发送类型
            /// </summary>
            [JsonConverter(typeof(StringEnumConverter))]
            public NotifyType Type { get; set; }
        }

    其它的都不变,在Type属性上加上了JsonConverter(typeof(StringEnumConverter))表示将枚举值转换成对应的字符串,StringEnumConverterNewtonsoft.Json内置的转换类型,最终输出结果

    https://images2015.cnblogs.com/blog/336693/201509/336693-20150910172109044-1714459886.png

     

    .自定义类型转换

    默认情况下对于实体里面的Boolean系统是格式化成true或者false,对于true转成"" false转成""这种需求改怎么实现了?我们可以自定义类型转换实现该需求,下面看实例

    public class BoolConvert : JsonConverter
        {
            private string[] arrBString { get; set; }
    
     
            public BoolConvert()
            {
                arrBString = "是,否".Split(',');
            }
    
     
            /// <summary>
            /// 构造函数
            /// </summary>
            /// <param name="BooleanString">将bool值转换成的字符串值</param>
            public BoolConvert(string BooleanString)
            {
                if (string.IsNullOrEmpty(BooleanString))
                {
                    throw new ArgumentNullException();
                }
                arrBString = BooleanString.Split(',');
                if (arrBString.Length != 2)
                {
                    throw new ArgumentException("BooleanString格式不符合规定");
                }
            }
    
     
    
     
            public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
            {
                bool isNullable = IsNullableType(objectType);
                Type t = isNullable ? Nullable.GetUnderlyingType(objectType) : objectType;
    
     
                if (reader.TokenType == JsonToken.Null)
                {
                    if (!IsNullableType(objectType))
                    {
                        throw new Exception(string.Format("不能转换null value to {0}.", objectType));
                    }
    
     
                    return null;
                }
    
     
                try
                {
                    if (reader.TokenType == JsonToken.String)
                    {
                        string boolText = reader.Value.ToString();
                        if (boolText.Equals(arrBString[0], StringComparison.OrdinalIgnoreCase))
                        {
                            return true;
                        }
                        else if (boolText.Equals(arrBString[1], StringComparison.OrdinalIgnoreCase))
                        {
                            return false;
                        }
                    }
    
     
                    if (reader.TokenType == JsonToken.Integer)
                    {
                        //数值
                        return Convert.ToInt32(reader.Value) == 1;
                    }
                }
                catch (Exception ex)
                {
                    throw new Exception(string.Format("Error converting value {0} to type '{1}'", reader.Value, objectType));
                }
                throw new Exception(string.Format("Unexpected token {0} when parsing enum", reader.TokenType));
            }
    
     
            /// <summary>
            /// 判断是否为Bool类型
            /// </summary>
            /// <param name="objectType">类型</param>
            /// <returns>为bool类型则可以进行转换</returns>
            public override bool CanConvert(Type objectType)
            {
                return true;
            }
    
     
    
     
            public bool IsNullableType(Type t)
            {
                if (t == null)
                {
                    throw new ArgumentNullException("t");
                }
                return (t.BaseType.FullName=="System.ValueType" && t.GetGenericTypeDefinition() == typeof(Nullable<>));
            }
    
     
            public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
            {
                if (value == null)
                {
                    writer.WriteNull();
                    return;
                }
    
     
                bool bValue = (bool)value;
    
     
                if (bValue)
                {
                    writer.WriteValue(arrBString[0]);
                }
                else
                {
                    writer.WriteValue(arrBString[1]);
                }
            }
        }

     自定义了BoolConvert类型,继承自JsonConverter。构造函数参数BooleanString可以让我们自定义将true false转换成相应字符串。下面看实体里面怎么使用这个自定义转换类型

        public class Person
        {
            [JsonConverter(typeof(BoolConvert))]
            public bool IsMarry { get; set; }
        }

    https://images2015.cnblogs.com/blog/336693/201512/336693-20151214101004068-161668511.png

    相应的有什么个性化的转换需求,都可以使用自定义转换类型的方式实现。

     

    .全局序列化设置

    文章开头提出了Null值字段怎么不返回的问题,相应的在高级用法也给出了相应的解决方案使用jsetting.NullValueHandling = NullValueHandling.Ignore; 来设置不返回空值。这样有个麻烦的地方,每个不想返回空值的序列化都需设置一下。可以对序列化设置一些默认值方式么?下面将解答

      Newtonsoft.Json.JsonSerializerSettings setting = new Newtonsoft.Json.JsonSerializerSettings();
       JsonConvert.DefaultSettings = new Func<JsonSerializerSettings>(() =>
       {
    
        //日期类型默认格式化处理
         setting.DateFormatHandling = Newtonsoft.Json.DateFormatHandling.MicrosoftDateFormat;
          setting.DateFormatString = "yyyy-MM-dd HH:mm:ss";
    
        //空值处理
          setting.NullValueHandling = NullValueHandling.Ignore;
    
    
    
          //高级用法九中的Bool类型转换 设置
          setting.Converters.Add(new BoolConvert("是,否"));
    
     
          return setting;
       });

     

    这样设置以后,以后使用序列化的地方就不需要单独设置了,个人最喜欢设置的是空值处理这一块。

    回到顶部

    总结

      Newtonsoft.Json序列化库替我们想了很多特性,也实现了很多特性,除了上面介绍的几种高级用法外,还有其它的特殊用法,可以去官网进行学习。当然这里我目前最喜欢的特性就是那个忽略部分属性序列化的功能,很小的代码改动实现了接口的优化,提升了用户体验。

     

     

    Newtonsoft.Json,一款.NET中开源的Json序列化和反序列化类库(下载地址http://json.codeplex.com/)

             下面是Json序列化和反序列化的简单封装:

    /// <summary>

        /// Json帮助类

        /// </summary>

        public class JsonHelper

        {

            /// <summary>

            /// 将对象序列化为JSON格式

            /// </summary>

            /// <param name="o">对象</param>

            /// <returns>json字符串</returns>

            public static string SerializeObject(object o)

            {

                string json = JsonConvert.SerializeObject(o);

                return json;

            }

     

            /// <summary>

            /// 解析JSON字符串生成对象实体

            /// </summary>

            /// <typeparam name="T">对象类型</typeparam>

            /// <param name="json">json字符串(eg.{"ID":"112","Name":"石子儿"})</param>

            /// <returns>对象实体</returns>

            public static T DeserializeJsonToObject<T>(string json) where T : class

            {

                JsonSerializer serializer = new JsonSerializer();

                StringReader sr = new StringReader(json);

                object o = serializer.Deserialize(new JsonTextReader(sr), typeof(T));

                T t = o as T;

                return t;

            }

     

            /// <summary>

            /// 解析JSON数组生成对象实体集合

            /// </summary>

            /// <typeparam name="T">对象类型</typeparam>

            /// <param name="json">json数组字符串(eg.[{"ID":"112","Name":"石子儿"}])</param>

            /// <returns>对象实体集合</returns>

            public static List<T> DeserializeJsonToList<T>(string json) where T : class

            {

                JsonSerializer serializer = new JsonSerializer();

                StringReader sr = new StringReader(json);

                object o = serializer.Deserialize(new JsonTextReader(sr), typeof(List<T>));

                List<T> list = o as List<T>;

                return list;

            }

     

            /// <summary>

            /// 反序列化JSON到给定的匿名对象.

            /// </summary>

            /// <typeparam name="T">匿名对象类型</typeparam>

            /// <param name="json">json字符串</param>

            /// <param name="anonymousTypeObject">匿名对象</param>

            /// <returns>匿名对象</returns>

            public static T DeserializeAnonymousType<T>(string json, T anonymousTypeObject)

            {

                T t = JsonConvert.DeserializeAnonymousType(json, anonymousTypeObject);

                return t;

            }

        }

      为进一步理解Newtonsoft,写了一些测试的例子:

    /// <summary>

        /// Json测试

        /// </summary>

        public class JsonTest : IRun

        {

            public void Run()

            {

                Student sdudent = new Student();

                sdudent.ID = 1;

                sdudent.Name = "陈晨";

                sdudent.NickName = "石子儿";

                sdudent.Class = new Class() { Name = "CS0216", ID = 0216 };

     

                //实体序列化和反序列化

                string json1 = JsonHelper.SerializeObject(sdudent);

                //json1 : {"ID":1,"Name":"陈晨","NickName":"石子儿","Class":{"ID":216,"Name":"CS0216"}}

                Student sdudent1 = JsonHelper.DeserializeJsonToObject<Student>(json1);

     

                //实体集合序列化和反序列化

                List<Student> sdudentList = new List<Student>() { sdudent, sdudent1 };

                string json2 = JsonHelper.SerializeObject(sdudentList);

                //json: [{"ID":1,"Name":"陈晨","NickName":"石子儿","Class":{"ID":216,"Name":"CS0216"}},{"ID":1,"Name":"陈晨","NickName":"石子儿","Class":{"ID":216,"Name":"CS0216"}}]

                List<Student> sdudentList2 = JsonHelper.DeserializeJsonToList<Student>(json2);

     

                //DataTable序列化和反序列化

                DataTable dt = new DataTable();

                dt.TableName = "Student";

                dt.Columns.Add("ID", typeof(int));

                dt.Columns.Add("Name");

                dt.Columns.Add("NickName");

                DataRow dr = dt.NewRow();

                dr["ID"] = 112;

                dr["Name"] = "战三";

                dr["NickName"] = "小三";

                dt.Rows.Add(dr);

                string json3 = JsonHelper.SerializeObject(dt);

                //json3 : [{"ID":112,"Name":"战三","NickName":"小三"}]

                DataTable sdudentDt3 = JsonHelper.DeserializeJsonToObject<DataTable>(json3);

                List<Student> sdudentList3 = JsonHelper.DeserializeJsonToList<Student>(json3);

     

                //验证对象和数组

                Student sdudent4 = JsonHelper.DeserializeJsonToObject<Student>("{\"ID\":\"112\",\"Name\":\"石子儿\"}");

                List<Student> sdudentList4 = JsonHelper.DeserializeJsonToList<Student>("[{\"ID\":\"112\",\"Name\":\"石子儿\"}]");

     

                //匿名对象解析

                var tempEntity = new { ID = 0, Name = string.Empty };

                string json5 = JsonHelper.SerializeObject(tempEntity);

                //json5 : {"ID":0,"Name":""}

                tempEntity = JsonHelper.DeserializeAnonymousType("{\"ID\":\"112\",\"Name\":\"石子儿\"}", tempEntity);

                var tempStudent = new Student();

                tempStudent = JsonHelper.DeserializeAnonymousType("{\"ID\":\"112\",\"Name\":\"石子儿\"}", tempStudent);

     

                Console.Read();

            }

     

        }

     

        /// <summary>

        /// 学生信息实体

        /// </summary>

        public class Student

        {

            public int ID { get; set; }

            public string Name { get; set; }

            public string NickName { get; set; }

            public Class Class { get; set; }

        }

     

        /// <summary>

        /// 学生班级实体

        /// </summary>

        public class Class

        {

            public int ID { get; set; }

            public string Name { get; set; }

        }

     

             使用Json帮助类时,有两点需要注意下:

             1. 通常使用调用实体序列化SerializeObject()和反序列化DeserializeJsonToObject()两个方法就可以了。但有些情况下我们解析json字符串时,可能没有对应的实体类型(或者说不想添加对应的实体类),这时候可以用匿名对象解析方法DeserializeAnonymousType(),方便快捷,对应代码如下:

    //匿名对象解析

                var tempEntity = new { ID = 0, Name = string.Empty };

                string json5 = JsonHelper.SerializeObject(tempEntity);

                //json5 : {"ID":0,"Name":""}

                tempEntity = JsonHelper.DeserializeAnonymousType("{\"ID\":\"112\",\"Name\":\"石子儿\"}", tempEntity);

                Console.WriteLine(tempEntity.ID + ":" + tempEntity.Name);

             2. Json的两种结构数组和对象解析时略有不同。Json对象一般转换成实体,Json数组一般转换成实体集合。代码如下:

    //验证对象和数组

                Student sdudent4 = JsonHelper.DeserializeJsonToObject<Student>("{\"ID\":\"112\",\"Name\":\"石子儿\"}");

                List<Student> sdudentList4 = JsonHelper.DeserializeJsonToList<Student>("[{\"ID\":\"112\",\"Name\":\"石子儿\"}]");

             简单解释下Json对象和数组的含义:

             对象是以“{”(左括号)开始,“}”(右括号)结束。每个名称后跟一个“:”(冒号);“‘名称/之间运用 “,”(逗号)分隔。名称用引号括起来;值如果是字符串则必须用括号,数值型则不须要。例如:{"ID":"112","Name":"石子儿"}

             数组是值(value)的有序集合。一个数组以“[”(左中括号)开始,“]”(右中括号)结束。值之间运用 “,”(逗号)分隔。例如:[{"ID":"112","Name":"石子儿"},{"ID":"113","Name":"陈晨"}]

    展开全文

空空如也

1 2 3 4 5 ... 20
收藏数 7,313
精华内容 2,925
关键字:

newtonsoft