C#Json数据交互

问题：写项目时，难免会遇到前台和后台要进行数据交换，往前台传一个对象或一个对象集，往后台传一个对象，一个对象集。怎么传，你当然不能直接去传递一个对象或对象集，我们可以利用JSON数据相互之间传值。

Json在跨域之间传数据也非常方法，这是它的优点。

你需要知道：传递数据我们用JSON，JSON,JSON，前台传递JSON数据格式到后台，后台需要反序列化。后台传前台，需要序列化后传。

简单了解  JSon数据。

Json语法：

在 JS 语言中，一切都是对象。因此，任何支持的类型都可以通过 JSON 来表示，例如字符串、数字、对象、数组等。但是对象和数组是比较特殊且常用的两种类型：

• 对象表示为键值对
• 数据由逗号分隔
• 花括号保存对象
• 方括号保存数组

JSON 键/值对

JSON 键值对是用来保存 JS 对象的一种方式，和 JS 对象的写法也大同小异，键/值对组合中的键名写在前面并用双引号 "" 包裹，使用冒号 : 分隔，然后紧接着值：

{"firstName": "John"}

这很容易理解，等价于这条 JavaScript 语句：

{firstName = "John"}

 

 

最容易误解的就是Json和JS里面的对象了

JSON 是 JS 对象的字符串表示法，它使用文本表示一个 JS 对象的信息，本质是一个字符串。

知道了这一点区分JSON和JS对象就很简单了。

例如：

  <script>
            var obj = { a: 'Hello', b: 'World' }; //这是一个对象，注意键名也是可以使用引号包裹的
            var json = '{"a": "Hello", "b": "World"}'; //这是一个 JSON 字符串，本质是一个字符串
            console.log(obj);
            console.log(obj.a);//JS对象可以直接用
 
            console.log(json);  //就是一个字符串
            console.log(json.a);  //JSON格式不好直接用，需要转型
        </script>

 JS自带方法可以让我们再JSON和对象之间相互转换

 <script>
          // 要实现从对象转换为 JSON 字符串，使用 JSON.stringify() 方法：
            //序列化
            var json = JSON.stringify({ a: 'Hello', b: 'World' }); //结果是 '{"a": "Hello", "b": "World"}'
            console.log(json);
            // 要实现从 JSON 转换为对象，使用 JSON.parse() 方法：
           //反序列化
            var obj = JSON.parse('{"a": "Hello", "b": "World"}'); //结果是 {a: 'Hello', b: 'World'}
            console.log(obj);
        </script>

   <script>
            //表示对象
            // JSON最常用的格式是对象的 键值对。例如下面这样：
            var dd = { "firstName": "Brett", "lastName": "McLaughlin" };
            console.log(dd.firstName);
            // 表示数组
            //和普通的 JS 数组一样，JSON 表示数组的方式也是使用方括号 []
            var ff = {
                "people": [{
                    "firstName": "Brett",
                    "lastName": "McLaughlin"
                },
                 {
                             "firstName": "Jason",
                             "lastName": "Hunter"
                         }
                ]
            };
            console.log(ff.people[].firstName);
        </script>

配合Aajx。

一条数据：

后台返回JSon数据，前台用

①字符串

 <script>
            $.ajax({
                type: "Post",
                url: "GetJson.ashx",
                data: "",
                dataType: "json",    //既然用到json，你就规定数据类型为json格式的
                async: true,
                success: function (data) {
                    console.log(data);
                    console.log(data.Name);
                }
            })
        </script>

 public void ProcessRequest(HttpContext context)  //一般处理程序
        {
            context.Response.ContentType = "text/plain";
            //返回JSon格式数据
             string aa = "{\"Name\":\"李某\",\"Age\":\"18\"}";   //json格式必须为这个
            context.Response.Write(aa);   //这里返回JSon数据，前台接受变成了Object，如果前台是string类型就转成对象。
         }

如果我们的JSON字符串很复咋，这样写字符串不太好。

②自带命名空间序列化

 context.Response.ContentType = "text/plain";
            //可以序列化和反序列化
            JavaScriptSerializer json = new JavaScriptSerializer();
            FunctionDemo.Model.Users usModel = new FunctionDemo.BLL.Users().GetModel();
            context.Response.Write(json.Serialize(usModel));

            $.ajax({
                type: "Post",
                url: "GetJson.ashx",
                data: "ob="+JSON.stringify(ob)+"&js="+js,
                dataType: "json",
                async: true,
                success: function (data) {
                    console.log(typeof (data));
                    console.log(data);
                    alert(data.LoginName);
                },
                error: function () {
                    alert(" 错了");
                }
            })

③借助我们的     这个dll    ———>      下载地址

  public void ProcessRequest(HttpContext context)
        {
            context.Response.ContentType = "text/plain";
            ////返回JSon格式数据
            // string aa = "{\"Name\":\"李某\",\"Age\":\"18\"}";   //json格式必须为这个
            //context.Response.Write(aa);   //这里返回JSon数据，前台接受变成了Object
           //可以把一张表的字段和值这样写
            JsonData jd = new JsonData();      JsonData.doc介绍
            jd["Name"] = "李某";
            jd["Age"] = ;
            context.Response.Write(jd.ToJson());   //这个跟上面的字符串JSon效果是一样的    可以简化我们的JSon字符串
        }

可以返回嵌套的

 //返回JSon格式数据
            string aa = "{\"Name\":\"李某\",\"Age\":\"18\",\"Love\":[{\"one\":\"运动\",\"two\":\"哦哦\"},{\"one\":\"看电影\"}]}";   //json格式必须为这个
            context.Response.Write(aa);   //这里返回JSon数据，前台接受变成了Object

  <script>         
 
            $.ajax({
                type: "Post",
                url: "GetJson.ashx",
                data: "",
                dataType: "json",
                async: true,
                success: function (data) {
                    console.log(data);
                    console.log(data.Name);
                    console.log(data.Love[].one);
                }
            })
        </script>

发现问题：

不管是我们手写Json字符串，还是利用JsonData转成JSON格式，你会发现都需要你去构造，如果你需要得到一张表，并且列很多，你要写到什么。并且有个很严重的缺点，就是获取多条数据的时候改怎么处理，很麻烦。以上的只能使用与小量数据，还好我们知道一个dll可以很好的解决这个问题。

④这个dll之前也用过，就是 Newtonsoft.Json   下载地址：点击

我们的来看看列子。

  public void ProcessRequest(HttpContext context)
        {
            context.Response.ContentType = "text/plain";
            //  DataSet ds = new FunctionDemo.BLL.Users().GetList("");
            FunctionDemo.Model.Users usModel = new FunctionDemo.BLL.Users().GetModel();
            //  JsonConvert.SerializeObject  这个静态方法  翻译就是序列化对象
            context.Response.Write(JsonConvert.SerializeObject(usModel));    //不能直接返回一个对象，或一个数据集
        }

 <script>         
 
            $.ajax({
                type: "Post",
                url: "GetJson.ashx",
                data: "",
                dataType: "json",
                async: true,
                success: function (data) {
                    console.log(typeof(data));
                    console.log(data);
 
                },
                error: function () {
                    alert(" 错了");
                }
            })
        </script>

   public void ProcessRequest(HttpContext context)
        {
            context.Response.ContentType = "text/plain";
             DataSet ds = new FunctionDemo.BLL.Users().GetList("");
            FunctionDemo.Model.Users usModel = new FunctionDemo.BLL.Users().GetModel();
            //  JsonConvert.SerializeObject  这个静态方法  翻译就是序列化对象
            //可以自己打造一个对象，把需要的数据填写进去   这个位子很灵活需要根据你想要的进行处理
            //也可以打造一张表   就可以添加很多数据了
            var dd= new { Name = usModel.LoginName, Age = , Sex = "男" };        
 
            context.Response.Write(JsonConvert.SerializeObject(dd));
        }

多条数据

   public void ProcessRequest(HttpContext context)
        {
            context.Response.ContentType = "text/plain";
             DataSet ds = new FunctionDemo.BLL.Users().GetList("");
            FunctionDemo.Model.Users usModel = new FunctionDemo.BLL.Users().GetModel();
            //  JsonConvert.SerializeObject  这个静态方法  翻译就是序列化对象             
 
            context.Response.Write(JsonConvert.SerializeObject(ds.Tables[]));
        }

 <script>         
 
            $.ajax({
                type: "Post",
                url: "GetJson.ashx",
                data: "",
                dataType: "json",
                async: true,
                success: function (data) {
                    console.log(typeof(data));
                    console.log(data);
                    console.log(`姓名:${data[].LoginName}`);                 
 
                },
                error: function () {
                    alert(" 错了");
                }
            })
        </script>

总结：在后台获取数据返回时需要序列化成JSON格式的数据，在前台接收时可用先看下数据类型，如果是JSON数据格式就转下型，无非就是Eval(data)和JSon.Pase（data）。

在后台我们返回JSON字符串，在前台我们需要变成Object.

前台返回JSON数据后台接收

这个前台都是一样的，下面主要看看后台怎么反序列化数据

 <script>
            var ob = { "LoginName": "李某", "PassWord": "" }; //对象    这里的属性跟你的类字段一样的，不要自己瞎起名字
            var js = '{"LoginName":"社会我李哥","PassWord":"哦"}'; //JSON
           //传递的数据必须为JSON格式的
          //把对象转成JSon字符串传进入
            $.ajax({
                type: "Post",
                url: "GetJson.ashx",
                data: "ob="+JSON.stringify(ob)+"&js="+js, //测试传一个对象，不转型的时候，后台无法处理，所以传递必须为JSON数据格式   一个，数组都可以
                dataType: "json",
                async: true,
                success: function (data) {
                    console.log(typeof (data));
                    console.log(data);
                    alert(data.LoginName);
                },
                error: function () {
                    alert(" 错了");
                }
            })
        </script>

后台：

            string ob = context.Request.Form["ob"];// "{\"LoginName\":\"李某\",\"PassWord\":\"159\"}"
            string js = context.Request.Form["js"];// "{\"LoginName\":\"社会我李哥\",\"PassWord\":\"哦\"}"
 
            //下面需要做的就是把JSON转成对象（一个确定的对象）
 
            //①自带的
            JavaScriptSerializer json = new JavaScriptSerializer();
            //反序列化，主要他需要的参数，如果是数据集 就换成 List<T>
            FunctionDemo.Model.Users one = json.Deserialize(ob, typeof(FunctionDemo.Model.Users)) as FunctionDemo.Model.Users;
 
            //②dll    typeof(T) 这个参数一个要带，不然成功不了
            FunctionDemo.Model.Users model = JsonConvert.DeserializeObject(js, typeof(FunctionDemo.Model.Users)) as FunctionDemo.Model.Users;
                //或者   JsonConvert.DeserializeObject<FunctionDemo.Model.Users>(js);
             //如果你传递的JSON数据没有确切的类型来接受，你自己可以在上面写一个 class ,属性值更你传递过来的属性是一一对应的就行
          

经过测试获取成功

总结：前台传数据之前就需要转成JSON格式，后台才好反序列化。

到此Json传递数据就完了。

 

 要点：传递的参数是JSON类型，接受成功了转成对象使用