JSON.NET概述（json net）

25-02-11 23

如果您想了解JSON.NET概述和jsonnet的知识，那么本篇文章将是您的不二之选。我们将深入剖析JSON.NET概述的各个方面，并为您解答jsonnet的疑在这篇文章中，我们将为您介绍JSON.N

如果您想了解JSON.NET概述和json net的知识，那么本篇文章将是您的不二之选。我们将深入剖析JSON.NET概述的各个方面，并为您解答json net的疑在这篇文章中，我们将为您介绍JSON.NET概述的相关知识，同时也会详细的解释json net的运用方法，并给出实际的案例分析，希望能帮助到您！

本文目录一览：

JSON.NET概述（json net）
.net – 在Newtonsoft.Json库中获取Raw json字符串
.net 使用 Newtonsoft.Json 输出树状 json字符串
.Net使用Newtonsoft.Json.dll(JSON.NET)对象序列化成json、反序列化json示例教程
.Net环境下Newtonsoft.Json与jquery $.getJSON结合用法

JSON.NET概述（json net）

http://book.2cto.com/201301/15190.html

1. JSON.NET概述

当JSON逐渐成为Ajax的标准数据交互格式时，在.NET中处理JSON数据只能使用字符串拼接的方法，十分麻烦，因而催生了JSON.NET这个项目。

JSON.NET是一个免费的开源项目，大家可以登录http://json.codeplex.com/下载最新版本，本书使用的版本是4.0 release 1，本节的示例将使用该版本进行演示。

JSON.NET的功能有很多，本书主要讲述以下两个Ext JS项目常用的功能：

通过序列化方法将.NET对象转换为JSON对象。

使用LINQ to JSON读写JSON对象。

2. 配置JSON.NET

在JSON.NET压缩包的bin目录下有Net、Net20、Net35、Silverlight和WindowsPhone5个目录，目录里有对应不同.Net Framework版本的库文件，根据使用的.Net Framework版本使用对应的库文件就可以了。譬如本书的例子使用的是.Net Framework 4.0版本，因而将Net35目录下的Newtonsoft.Json.Net35.dll文件添加到项目的bin目录就可以了。

要使用序列化功能，需在代码中加入以下引用代码：
using Newtonsoft.Json;

如果要使用LINQ to JSON，需在代码中加入以下引用代码：
using Newtonsoft.Json.Linq;

3. 序列化

在开发Web应用时，一般都需要将数据库查询出的数据转换为JSON格式文本传送回客户端，这就需要进行序列化。在JSON.NET中，要进行序列化，常用的是JsonConvert对象的SerializeObject方法。其基本的语法格式如下：
JsonConvert.SerializeObject(object)

代码中“object”就是要序列化的.NET对象。序列化后的返回值是字符串。

下面我们通过一个例子来加深一下认识。例子主要实现的功能是将微软示例数据库“northwnd”中客户表（Customers）的所有客户数据以JSON格式返回客户端，其代码如下：
public string Message { get; set; }

protected void Page_Load(object sender,EventArgs e)
{
northwindEntities ne = new northwindEntities();
var q = ne.Customers.OrderBy(m=>m.CompanyName)
.Select(m=>new {
m.CustomerID,
m.CompanyName,
m.Country,
m.City,
m.Address,
m.PostalCode,
m.Phone,
m.Region
});
Message = JsonConvert.SerializeObject(q);

}

代码中，首先从实体模型中查询出数据集合“q”，然后将数据集合“q”序列化成JSON格式字符串并赋值给变量“Message”，最后在页面中输出。在浏览器中打开页面将看到以下的结果：
[{"CustomerID":"ALFKI","CompanyName":"Alfreds Futterkiste","Country":"Germany","City":"Berlin","Address":"Obere Str. 57","PostalCode":"12209","Phone":"030-0074321","Region":null},
…,
{"CustomerID":"WOLZA","CompanyName":"Wolski Zajazd","Country":"Poland","City":"Warszawa","Address":"ul. Filtrowa 68","PostalCode":"01-012","Phone":"(26) 642-7012","Region":null}]

从上面的例子可以看到，将查询数据序列化成JSON文本是一件非常简单的事。其实，对.NET对象的序列化还有很多方式，囿于篇幅，本书就不一一介绍了，有兴趣可以详细阅读JSON.NET的文档。

4. LINQ to JSON

事实上，Ext JS对数据返回的格式是有一定要求的，并不是简单地返回序列化后的数据就行，这时就需要用到LINQ to JSON。LINQ to JSON的作用就是根据需要的JSON格式组织文本数据。

LINQ to JSON需要使用到JObject、JArray、JPropery和JValue 4个对象，这4个对象的详细说明如表1-1所示。

表1-1　LINQ to JSON对象说明
对　　象说　　明
JObject　生成一个JSON对象，形象点来说就是生成“｛｝”
JArray　生成一个JSON数组，形象点来说就是生成“[]”
JProperty　生成一个JSON数据，格式如下：
　JProperty(name,value)
　name:类型为字符串，关键字　
　value：类型为对象，值
JValue　直接生成一个JSON值。在生成仅有值的数组时，就需要使用JValue进行转换。其格式如下：
　JValue(value)
　value：类型为对象，值

下面我们通过一个例子说明如何使用LINQ to JSON。Ext JS的所需JSON格式数据一般如下：
{
　"total":5,//记录总数
　"rows":[
　 //JSON对象格式的数据列表
　]
}

示例将演示如何根据以上格式返回客户表数据，代码如下：
public string Message { get; set; }

protected void Page_Load(object sender,EventArgs e)
{
northwindEntities ne = new northwindEntities();
var q = ne.Customers.OrderBy(m => m.CompanyName)
.Select(m => new
{
m.CustomerID,
m.ContactName
}
).ToList();
Message = new JObject(
new JProperty("total",q.Count()),//创建记录总数
new JProperty("rows",
new JArray( //创建数据数组
from p in q
select new JObject(
new JProperty("id",p.CustomerID),
new JProperty("cpname",p.CompanyName),
new JProperty("contactName",p.ContactName)
)
)
)
).ToString();
}

从上面的代码可以看到，构建固定格式的JSON数据是相当直观的。将粗体代码与格式数据对比，可以看到，最外层的JObject创建了格式中最外层的“｛｝”，然后依次使用JProperty生成记录总数数据和数据列表。而代码中的JArray的作用就是生成“[]”，将使用LINQ to JSON方式生成的一个个数据对象组合成数组。本来是希望直接通过LINQ to JSON将实体模型转换成JSON的，但这样会产生“LINQ to Entities 仅支持无参数构造函数和初始值设定项”的错误，因而本示例先将查询的数据转换为列表（ToList()），再进行转换。使用LINQ to JSON可直接在select语句生成JSON数据对象，无须其他转换过程，相当方便。在使用select语句生成数据对象时，首先使用JObject生成“｛｝”，然后使用JProperty生成对象的数据。

在浏览器中打开页面，将看到以下的结果：
{ "total": 91,"rows": [ { "id": "ALFKI","cpname": "Alfreds Futterkiste","contactName": "Maria Anders" },{ "id": "ANATR","cpname": "Ana Trujillo Emparedadosy helados","contactName": "Ana Trujillo" },
{ "id": "WOLZA","cpname": "Wolski Zajazd","contactName": "Zbyszek Piestrzeniewicz" } ] }

注意　千万不要使用序列化的方式生成“rows”的值，如下面的代码：
　　　 new JProperty("rows",JsonConvert.SerializeObject(q)) ;

因为这样生成的“rows”值是字符串，而不是数组。

5. 处理客户端提交的JSON数据

有时候，在客户端以JSON格式将数据提交到服务器比较方便。譬如，直接在Grid修改了不同行和列的数据，最后一次性将修改的数据提交到服务器端处理，这时候，使用JSON格式提交数据会很方便，例如以下提交的数据：
[
{id:"12345",title:"文章一",author:"李四"},
{id:"12367",author:"张三"},
{id:"17777",isShow:true}
]

数据表示在Grid中修改了3行数据，第1行修改了标题（title）和作者（author），第2行修改了作者，第3行修改了是否显示（isShow）。

在服务器端使用JObject或JArray的Parse方法就可轻松地将字符串转换为JSON对象，然后通过对象的方法提取数据，下面是服务器端的处理代码：
public string Message { get; set; }
protected void Page_Load(object sender,EventArgs e)
{
string jsonString = @"
[
{id:'12345',title:'文章一',author:'李四'},
{id:'12367',author:'张三'},
{id:'17777',isShow:true}
]
";
JArray json = JArray.Parse(jsonString);
Message = @"<table border='1'>
<tr><td width='80'>ID</td><td width='100'>字段</td><td width='100'> 值</td></tr>
";
string tpl = "<tr><td>{0}</td><td>{1}</td><td>{2}</td></tr>";
foreach (JObject jobject in json)
{

foreach (var a in jobject)
{
if(a.Value.ToString()!="id")
Message += String.Format(tpl,(string)jobject["id"],a.Key,a.Value);
}
}
Message += "</table>";

在代码中，因为已知数据是使用数组形式提交的，所以采用JArray的Parse方法。

什么？你不知道数据是以数组还是对象形式提交？

这……

数据的提交方式应该是一种双方的约定，不然要处理未知的数据会很麻烦，所以不用担心这个问题。

第1层foreach循环用来获取JObject对象。第2层foreach用来获取修改过的字段名称。在这里要注意，数据默认已约定存在id这个字段。

代码运行后将看到如图1-4所示结果。

从结果可以看到，数据已经被分拆出来，这样你就可以根据id和字段去更新数据库了。

.net – 在Newtonsoft.Json库中获取Raw json字符串

我有这样的json

{
    "name": "somenameofevent","type": "event","data": {
        "object": {
            "age": "18","petName": "18"
        },"desct": {
        }
    }
}

我有2个像这样的对象

public class CustEvent
{
    [JsonProperty("name")]
    public string Name { get; set; }
    [JsonProperty("type")]
    public string EventType{ get; set; }
    [JsonProperty("data")]
    public SomeData Data{ get; set; }
}

public class SomeData
{
    [JsonProperty("object")]
    public String SomeObject { get; set;}
    [JsonProperty("dsct")]
    public String SomeDesct { get; set; }
}

我用来解析json对象Newtonsoft.NET库.以及如何将RAW JSON转换为SomeObject,SomeDesct属性？在JSON中,“data.object …”是复杂的对象,我想只获得RAW JSON String到这些属性.你可以帮我吗？

您不需要编写任何转换器,只需使用 JRaw类型,如下所示：

public class SomeData
{
    [JsonProperty("object")]
    public JRaw SomeObject { get; set;}
    [JsonProperty("dsct")]
    public JRaw SomeDesct { get; set; }
}

然后,您可以通过检查.Value属性来访问原始值：

var rawJsonDesct = (string)data.someDesct.Value;

如果要保留字符串签名,只需将JSON序列化为隐藏属性,并在访问者调用中进行字符串转换.

.net 使用 Newtonsoft.Json 输出树状 json字符串

测试环境：.net FrameWork 4.0

操作系统：window Server 2008 R2

Newtonsoft.Json 下载地址：http://json.codeplex.com/

1、解压缩下载文件夹：Json50r8

2、引入Json50r8/Bin 下的相对应.net版本的dll文件到项目中

执行以下代码：

using System;
using System.Collections.Generic;
using Newtonsoft.Json;

public partial class _Default : System.Web.UI.Page
{
    private string jsonString = @"[
        { 'id': '1','text': '电脑整机','parentid': '0','children': [
    { 'id': '2','text': '笔记本','parentid': '1','children': [
{ 'id': '31','text': 'SONY','parentid': '2','children': [] },{ 'id': '23','text': 'LENOVO',{ 'id': '25','text': 'IBM',{ 'id': '26','text': '宏基',{ 'id': '27','text': '联想',{ 'id': '28','text': '联想2','children': [] }
   ]
    },{ 'id': '3','text': '上网本',{ 'id': '4','text': '平板电脑',{ 'id': '5','text': '台式机',{ 'id': '6','text': '服务器','children': [] }
]
        },{ 'id': '7','text': '电脑配件','children': [
{ 'id': '8','text': 'cpu','parentid': '7',{ 'id': '9','text': '主板',{ 'id': '10','text': '显卡',{ 'id': '11','text': '硬盘',{ 'id': '12','text': '内存',{ 'id': '13','text': '机箱',{ 'id': '14','text': '电源',{ 'id': '15','text': '显示器',{ 'id': '16','text': '刻录机/光驱',{ 'id': '17','text': '声卡',{ 'id': '18','text': '扩展卡','children': [] }
]
   },{ 'id': '32','text': '手机','children': [
  {
      'id': '33','text': '诺基亚','parentid': '32','children': [
                                  { 'id': '34','text': '华为','children': [] }
                                  ]
  },{ 'id': '34','text': '三星','text': '小米','text': '苹果','children': [] }
                                                                 	]
    },'text': '篮球','parentId': '1','children': [] }
];";

    protected void Page_Load(object sender,EventArgs e)
    {
        treeNode rootNode = new treeNode();
        rootNode.id="1";
        rootNode.text="电脑整机";
        rootNode.parentid="0";
        
        treeNode childNode1 = new treeNode();
        childNode1.id="2";
        childNode1.text="笔记本";
        childNode1.parentid="1";

        treeNode childNode2 = new treeNode();
        childNode2.id="3";
        childNode2.text="SONY";
        childNode2.parentid="1";

        if (rootNode.children == null)
            rootNode.children = new List<treeNode>();

        rootNode.children.Add(childNode1);
        rootNode.children.Add(childNode2);

        string json = JsonConvert.SerializeObject(rootNode,Formatting.Indented);
    }

    /// <summary>
    /// 树结构(根据js插件定义的数据结构)
    /// </summary>
    public class treeNode
    {
        private string _id;

        private string _text;

        private string _parentid;

        private List<treeNode> _children;

        public string id
        {
            get { return _id; }
            set { _id = value; }
        }
        public string text
        {
            get { return _text; }
            set { _text = value; }
        }
        public string parentid
        {
            get { return _parentid; }
            set { _parentid = value; }
        }
        public List<treeNode> children
        {
            get { return _children; }
            set { _children = value; }
        }
    }
}

.Net使用Newtonsoft.Json.dll(JSON.NET)对象序列化成json、反序列化json示例教程

JSON作为一种轻量级的数据交换格式，简单灵活，被很多系统用来数据交互，作为一名.NET开发人员，JSON.NET无疑是最好的序列化框架，支持XML和JSON序列化，高性能，免费开源，支持LINQ查询。目前已被微软集成于webapi框架之中，因此，熟练掌握JSON.NET相当重要，这篇文章是零度参考官网整理的示例，通过这些示例，可以全面了解JSON.NET提供的功能。

Newtonsoft.Json的地址：

官网：http://json.codeplex.com/

源码地址：https://github.com/JamesNK/Newtonsoft.Json

Newtonsoft.Json.dll下载：https://github.com/JamesNK/Newtonsoft.Json/releases

1、使用Newtonsoft.Json(JSON.NET)序列化对象,通过Newtonsoft.Json.Formatting将json格式化输出。

            Account account = new Account
            {
                Email = "1930906722@qq.com",Active = true,CreatedDate =DateTime.Now,Roles = new List<string> { "User","Admin" }
            };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(account,Newtonsoft.Json.Formatting.Indented);
            Console.WriteLine(json);

    public class Account
    {
        public string Name { get; set; }
        public string Email { get; set; }
        public bool Active { get; set; }
        public DateTime CreatedDate { get; set; }
        public IList<string> Roles { get; set; }
    }

执行结果：

2、使用Newtonsoft.Json(JSON.NET)序列化List集合：

            List<string> videogames = new List<string> { "HTML5","JavaScript",".net","c#",".net core" };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(videogames);
            Console.WriteLine(json);

执行结果：

3、使用Newtonsoft.Json(JSON.NET)序列化dictionary字典

            System.Collections.Generic.Dictionary<string,string> dic = new System.Collections.Generic.Dictionary<string,string>
            {
                { "Name","张三" },{ "Age","20" },{ "Email","193090622@qq.com" }
            };
            string json1 = Newtonsoft.Json.JsonConvert.SerializeObject(dic,Newtonsoft.Json.Formatting.Indented);
            Console.WriteLine(json1);
            Console.WriteLine("");
            Console.WriteLine("未格式化的json：");
            string json2 = Newtonsoft.Json.JsonConvert.SerializeObject(dic,Newtonsoft.Json.Formatting.None);
            Console.WriteLine(json2);

执行结果：

4、Newtonsoft.Json(JSON.NET)将序列化结果保存到指定的文件：

            User movie = new User { Name = "张三",Age = 1993 };
            using (System.IO.StreamWriter file = System.IO.File.CreateText(@"F:\UserInfo.txt"))
            {
                Newtonsoft.Json.JsonSerializer serializer = new Newtonsoft.Json.JsonSerializer();
                serializer.Serialize(file,movie);
            }

    public class User
    {
        public string Name { set; get; }
        public int Age { set; get; }
    }

执行后保存到文件的结果：

5、Newtonsoft.Json(JSON.NET)基于枚举类型的JsonConverters转换器

            List<JosnEnum> list = new List<JosnEnum> { JosnEnum.NotStartus,JosnEnum.Startus };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(list);
            Console.WriteLine(json);
            Console.WriteLine("");

            System.Collections.Generic.Dictionary<string,int> dic = new System.Collections.Generic.Dictionary<string,int>
            { 
            {((JosnEnum)(int)JosnEnum.NotStartus).ToString(),(int)JosnEnum.NotStartus},{((JosnEnum)(int)JosnEnum.Startus).ToString(),(int)JosnEnum.Startus}
            };
            string dicJson = Newtonsoft.Json.JsonConvert.SerializeObject(dic);
            Console.WriteLine(dicJson);

            Console.WriteLine("");
            List<JosnEnum> list2 = new List<JosnEnum>
            {
                JosnEnum.NotStartus,JosnEnum.Startus
            };
            string json3 = Newtonsoft.Json.JsonConvert.SerializeObject(list2,new Newtonsoft.Json.Converters.StringEnumConverter());
            Console.WriteLine(json3);

            Console.WriteLine("");

            List<JosnEnum> result = Newtonsoft.Json.JsonConvert.DeserializeObject<List<JosnEnum>>(json3,new Newtonsoft.Json.Converters.StringEnumConverter());
            Console.WriteLine(string.Join(",",result.Select(c => c.ToString())));

    public enum JosnEnum
    {
        NotStartus = 0,Startus = 1
    }

执行结果：

6、Newtonsoft.Json(JSON.NET)通过JRaw将JS函数序列化到JSON中

            JavaScriptSettings settings = new JavaScriptSettings
            {
                OnLoadFunction = new Newtonsoft.Json.Linq.JRaw("OnLoad"),OnSucceedFunction = new Newtonsoft.Json.Linq.JRaw("function(e) { alert(e); }")
            };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(settings,Newtonsoft.Json.Formatting.Indented);
            Console.WriteLine(json);

    public class JavaScriptSettings
    {
        public Newtonsoft.Json.Linq.JRaw OnLoadFunction { get; set; }
        public Newtonsoft.Json.Linq.JRaw OnSucceedFunction { get; set; }
    }

7、使用Newtonsoft.Json(JSON.NET)将json反序列化对象

  string json = @"{
   'Email': '1930906722@qq.com','Active': true,'CreatedDate': '2016-11-26 20:39','Roles': [
     'User','Admin'
]
 }";
            Account account = Newtonsoft.Json.JsonConvert.DeserializeObject<Account>(json);
            Console.WriteLine(account.Email);

    public class Account
    {
        public string Name { get; set; }
        public string Email { get; set; }
        public bool Active { get; set; }
        public DateTime CreatedDate { get; set; }
        public IList<string> Roles { get; set; }
    }

执行结果：

8、使用Newtonsoft.Json(JSON.NET)反序列化List集合：

            string json = @"['Html5','C#','.Net','.Net Core']";
            List<string> videogames = Newtonsoft.Json.JsonConvert.DeserializeObject<List<string>>(json);
            Console.WriteLine(string.Join(",videogames));

执行结果：

9、使用Newtonsoft.Json(JSON.NET)反序列化dictionary字典

            string json = @"{'Name': '张三','Age': '23'}";
            var htmlAttributes = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string,string>>(json);
            Console.WriteLine(htmlAttributes["Name"]);
            Console.WriteLine(htmlAttributes["Age"]);

执行结果：

10、使用Newtonsoft.Json(JSON.NET)序列化var匿名类型，有时候，我们并不需要先定义一个类，然后new一个对象后再进行序列化，JSON.NET支持匿名类型的序列化和反序列化。

            var test1 = new { Name = "李四",Age = 26 };
            var json = Newtonsoft.Json.JsonConvert.SerializeObject(test1);
            Console.WriteLine(json);

            Console.WriteLine("");
            var test2 = new { Name = "",Age = 0 };
            string json1 = @"{'Name':'张三','Age':'25'}";
            var result = Newtonsoft.Json.JsonConvert.DeserializeAnonymousType(json1,test2);
            Console.WriteLine(result.Name);

执行结果：

11、Newtonsoft.Json(JSON.NET)用新JSON字符串填充指定对象的属性值

            Account account = new Account
            {
                Email = "1930906722@qq.com",CreatedDate = DateTime.Now,"Admin" }
            };
            string json = @"{'Active': false,'Roles': ['Expired']}";
            Newtonsoft.Json.JsonConvert.PopulateObject(json,account);
            Console.WriteLine(account.Active);
            Console.WriteLine(account.Email);

    public class Account
    {
        public string Name { get; set; }
        public string Email { get; set; }
        public bool Active { get; set; }
        public DateTime CreatedDate { get; set; }
        public IList<string> Roles { get; set; }
    }

执行结果：

12、使用Newtonsoft.Json(JSON.NET)反序列化时可指定构造函数：

首先我们定义如下的类型，我们希望JSON.NET反序列化对象时使用第2个构造函数，我们将第一个默认构造函数屏蔽，标记为私有private修饰符。第2个构造函数需要指定一个website对象作为参数，如果提供的参数为null则抛出异常：

public class Website
{
    public string Url { get; set; }
    private Website()
    {
    }
    public Website(Website website)
    {
        if (website == null) throw new ArgumentNullException("website");
        Url = website.Url;
    }
}

现在使用一般的方式反序列化一个JSON字符串。执行出现的结果：

我们发现该序列化方法抛出了异常，并没有按照我们预想的方式进行反序列化，JSON.NET提供如下的方式指定公有构造函数。

            string json = @"{'Url':'http://www.cnblogs.com/linJie1930906722/'}";
            Website website = Newtonsoft.Json.JsonConvert.DeserializeObject<Website>(json,new Newtonsoft.Json.JsonSerializerSettings
            {
                ConstructorHandling = Newtonsoft.Json.ConstructorHandling.AllowNonPublicDefaultConstructor
            });
            Console.WriteLine(website.Url);

执行结果：

另外，JSON.NET提供了指定任何构造函数的JsonConstructorAttribute特性，只需要在构造函数上标记，即可指定构造函数。

    public class Users
    {
        public string UserName { get; private set; }
        public bool Enabled { get; private set; }
        public Users()
        {
        }
        [Newtonsoft.Json.JsonConstructor]
        public Users(string userName,bool enabled)
        {
            UserName = userName;
            Enabled = enabled;
        }
    }

            string json = @"{""UserName"": ""希特勒"",""Enabled"": true}";
            Users user = Newtonsoft.Json.JsonConvert.DeserializeObject<Users>(json);
            Console.WriteLine(user.UserName);

执行结果：

13、当对象的属性为默认值(0或null)时不序列化该属性

    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public Person Partner { get; set; }
        public decimal? Salary { get; set; }
    }

            Person person1 = new Person();
            string json1 = Newtonsoft.Json.JsonConvert.SerializeObject(person1,Newtonsoft.Json.Formatting.Indented,new Newtonsoft.Json.JsonSerializerSettings
            {
                DefaultValueHandling = Newtonsoft.Json.DefaultValueHandling.Ignore
            });
            Console.WriteLine(json1);

            Console.WriteLine("");
            Person person2 = new Person(){Name = "奥巴马"};
            string json2 = Newtonsoft.Json.JsonConvert.SerializeObject(person2,new Newtonsoft.Json.JsonSerializerSettings
            {
                DefaultValueHandling = Newtonsoft.Json.DefaultValueHandling.Ignore
            });
            Console.WriteLine(json2);

执行结果：

14、Newtonsoft.Json（JSON.NET）中忽略null值得处理器

    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public Person Partner { get; set; }
        public decimal? Salary { get; set; }
    }

            Person person = new Person { Name = "张三",Age = 46 };
            string jsonIncludeNullValues = Newtonsoft.Json.JsonConvert.SerializeObject(person,Newtonsoft.Json.Formatting.Indented);
            Console.WriteLine(jsonIncludeNullValues);
            Console.WriteLine("");
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(person,new Newtonsoft.Json.JsonSerializerSettings
            {
                NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore
            });
            Console.WriteLine(json);

执行结果：

15、JSON.NET中循环引用的处理方法

            Employee employee1 = new Employee { Name = "张三" };
            Employee employee2 = new Employee { Name = "李四" };
            employee1.Manager = employee2;
            employee2.Manager = employee2;
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(employee1,new Newtonsoft.Json.JsonSerializerSettings
            {
                ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore
            });
            Console.WriteLine(json);

    public class Employee
    {
        public string Name { get; set; }
        public Employee Manager { get; set; }
    }

执行结果：

16、通过ContractResolver指定属性名首字母小写，通常，在.NET中属性采用PascalCase规则（首字母大写），在JavaScript中属性名使用CamelCase规则（首字母小写），我们希望序列化后的JSON字符串符合CamelCase规则，JSON.NET提供的ContractResolver可以设置属性名小写序列化

    public class User
    {
        public string Name { set; get; }
        public int Age { set; get; }
    }

            User person = new User { Name = "张三",Age =52 };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(person,new Newtonsoft.Json.JsonSerializerSettings
            {
                ContractResolver = new Newtonsoft.Json.Serialization.CamelCasePropertyNamesContractResolver()
            });
            Console.WriteLine(json);

执行结果：

17、JSON.NET中通过特性序列化枚举类型

    public enum ProductStatus
    { 
        NotConfirmed,Active,Deleted
    }

    public class Product
    {
        public string Name { get; set; }

        [Newtonsoft.Json.JsonConverter(typeof(Newtonsoft.Json.Converters.StringEnumConverter))]
        public ProductStatus Status { get; set; }
    }

            Product user = new Product { Name = @"羽绒服",Status = ProductStatus.Deleted };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(user,Newtonsoft.Json.Formatting.Indented);
            Console.WriteLine(json);

执行结果：

18、指定需要序列化的属性

    [Newtonsoft.Json.JsonObject(Newtonsoft.Json.MemberSerialization.OptIn)]
    public class Categroy
    {
        //Id不需要序列化
        public Guid Id { get; set; }

        [Newtonsoft.Json.JsonProperty]
        public string Name { get; set; }

        [Newtonsoft.Json.JsonProperty]
        public int Size { get; set; }
    }

            Categroy categroy = new Categroy
            {
                Id = Guid.NewGuid(),Name = "内衣",Size = 52
            };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(categroy,Newtonsoft.Json.Formatting.Indented);
            Console.WriteLine(json);

执行结果：

19、序列化对象时指定属性名

    public class Videogame
    {
        [Newtonsoft.Json.JsonProperty("name")]
        public string Name { get; set; }

        [Newtonsoft.Json.JsonProperty("release_date")]
        public DateTime ReleaseDate { get; set; }
    }

            Videogame starcraft = new Videogame
            {
                Name = "英雄联盟",ReleaseDate = DateTime.Now
            };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(starcraft,Newtonsoft.Json.Formatting.Indented);
            Console.WriteLine(json);

执行结果：

20、序列化时指定属性在JSON中的顺序

    public class Personl
    {
        [Newtonsoft.Json.JsonProperty(Order = 2)]
        public string FirstName { get; set; }

        [Newtonsoft.Json.JsonProperty(Order = 1)]
        public string LastName { get; set; }
    }

            Personl person = new Personl { FirstName = "张三",LastName = "李四" };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(person,Newtonsoft.Json.Formatting.Indented);
            Console.WriteLine(json);

执行结果：

21、反序列化指定属性是否必须有值必须不为null，在反序列化一个JSON时，可通过JsonProperty特性的required指定反序列化行为，当反序列化行为与指定的行为不匹配时，JSON.NET将抛出异常，required是枚举，required.Always表示属性必须有值切不能为null，required.AllowNull表示属性必须有值，但允许为null值。

    public class Order
    {
        [Newtonsoft.Json.JsonProperty(required = Newtonsoft.Json.required.Always)]
        public string Name { get; set; }

        [Newtonsoft.Json.JsonProperty(required = Newtonsoft.Json.required.AllowNull)]
        public DateTime? ReleaseDate { get; set; }
    }

            string json = @"{
    'Name': '促销订单','ReleaseDate': null
  }";
            Order order = Newtonsoft.Json.JsonConvert.DeserializeObject<Order>(json);
            Console.WriteLine(order.Name);
            Console.WriteLine(order.ReleaseDate);

执行结果：

22、通过特性指定null值忽略序列化

    public class Vessel
    {
        public string Name { get; set; }

        [Newtonsoft.Json.JsonProperty(NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
        public DateTime? launchdate { get; set; }
    }

            Vessel vessel = new Vessel { Name = "张三" };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(vessel,Newtonsoft.Json.Formatting.Indented);
            Console.WriteLine(json);

执行结果：

23、忽略不需要序列化的属性，并不是对象所有属性都要参与序列化，我们可以使用JsonIgnore特性排除不需要序列化的属性，下面示例中的PasswordHash将被忽略。

    public class Accounts
    {
        public string FullName { get; set; }
        public string EmailAddress { get; set; }
        [Newtonsoft.Json.JsonIgnore]
        public string PasswordHash { get; set; }
    }

            Accounts account = new Accounts
            {
                FullName = "admin",EmailAddress = "1930906722@qq.com",PasswordHash = "dfsfgerhtyhsasdhjyujtgwe454811sfsg8d"
            };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(account);
            Console.WriteLine(json);

执行结果：

24、序列化或反序列化时指定日期时间格式，JSON.NET中提供一个名为JsonSerializerSettings的设置对象，可通过此对象设置很多序列化和反序列化的行为，如果要设置JSON.NET序列化输出的日期时间格式，只需要指定格式化字符串即可。通过JsonSerializerSettings的DateFormatString属性指定日期时间格式：

    public class Customer
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public DateTime CreateDate { get; set; }
    }

            Customer custom = new Customer { FirstName = "张三",LastName = "李四",CreateDate = DateTime.Now };
            Newtonsoft.Json.JsonSerializerSettings settings = new Newtonsoft.Json.JsonSerializerSettings
            {
                DateFormatString = "yyyy-MM-dd HH:mm:ss",Formatting = Newtonsoft.Json.Formatting.Indented
            };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(custom,settings);
            Console.WriteLine(json);

执行结果：

.Net环境下Newtonsoft.Json与jquery $.getJSON结合用法

最近忙啊忙啊。。。今天还是抽点时间来写点小玩意：.Net环境下Newtonsoft.Json与jquery $.getJSON结合用法

1、首先你需要有一个Newtonsoft.Json.dll，下载地址在这：http://json.codeplex.com/，下载最新版本的，解压后到Bin目录找你对应版本的Newtonsoft.Json.dll，我的是.Net 3.5所以去Net35目录下找着Newtonsoft.Json.dll，将它作为引用添加到你网站项目里，（最快的添加办法是选中Newtonsoft.Json.dll后Ctrl+C，然后在VS@R_301_6256@案资源管理器里选中项目的bin文件夹按Ctrl+V）。

2、在项目里新建一个类，随便叫什么名字，主要是用来装数据的：

using System;
using System.Data;
using System.Configuration;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Linq;

/// <summary>
///Customer 的摘要说明
/// </summary>
public class Customer
{
	public Customer()
	{
		//
		//Todo: 在此处添加构造函数逻辑
		//
	}

    public int Unid { get; set; }
    public string CustomerName { get; set; }
    public string Memo { get; set; }
    public string Other { get; set; } 
}

2、在项目里新建一个ashx文件（新建项里的“一般处理程序”），我这里是Handler.ashx，它的主要作用是用来返回Json数据，先生成几个Customer然后用Newtonsoft.Json.JsonConvert.SerializeObject()序列化成json数据，代码很简单：

<%@ WebHandler Language="C#"%>

using System; 
using System.Web; 
using System.Data; 
using System.Text;
using System.Collections.Generic;

public class Handler : IHttpHandler {
    
    public void ProcessRequest (HttpContext context) {

        Customer customer = new Customer { Unid = 1,CustomerName = "哈哈哈",Memo = "小日本",Other = "小日本" };
        Customer customer2 = new Customer { Unid = 2,CustomerName = "哼哼哼",Memo = "棒子",Other = "棒子" };
        List<Customer> _list = new List<Customer>();
        _list.Add(customer);
        _list.Add(customer2);
        string strjson = Newtonsoft.Json.JsonConvert.SerializeObject(_list);//序列化成json数据
        context.Response.Write(strjson); 
    }
 
    public bool IsReusable {
        get {
            return false;
        }
    }
}

3、前端新建一个aspx页面，这里是Default2.aspx，写一段脚本来向Handler.ashx请求数据并显示出来：

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default2.aspx.cs" Inherits="Default2" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>无标题页</title>
    <script src="cssjs/jquery.js" type="text/javascript" language="javascript"></script>
     <script type="text/javascript">
     $(function(){
        $.getJSON("Handler.ashx",function(data) {
        var tt = "";
        $.each(data,function(k,v) {
            $.each(v,function(kk,vv) {
                tt += kk + "：" + vv + "<br/>";
            });
        });
        $("#divmessage").html(tt);
        });
     })
     
     </script>
</head>
<body>
    <form id="form1" runat="server">
    <div id="divmessage">
    
    </div>
    </form>
</body>
</html>

4、调试运行效果如下，访问Default2.aspx：

访问Handler.ashx：

5、其实JsonConvert.SerializeObject()还是很强大的，可以直接序列化DataTable，如下：

 string sql = "select top 5 gId,gName,price from goods order by gId";
        DataTable dt = sqlbase.ExecuteTable(CommandType.Text,sql,null);

        string strjson = Newtonsoft.Json.JsonConvert.SerializeObject(dt);
        context.Response.Write(strjson);

效果：

是不是很简单呢？新手可以学习学习，高手莫见笑。。。

今天关于JSON.NET概述和json net的分享就到这里，希望大家有所收获，若想了解更多关于.net – 在Newtonsoft.Json库中获取Raw json字符串、.net 使用 Newtonsoft.Json 输出树状 json字符串、.Net使用Newtonsoft.Json.dll(JSON.NET)对象序列化成json、反序列化json示例教程、.Net环境下Newtonsoft.Json与jquery $.getJSON结合用法等相关知识，可以在本站进行查询。

本文标签：