JS对象与json字符串格式,输出到前端JSON的几种方
分类:计算机编程

首先种:利用MODEL拼成要出口JSON的靶子。再用JSON.NET转成JSON输出到前面贰个(这种常用,就不及方了。)

  本文目的在于介绍借使经过C#将赢获得的XML文书档案转变来对应的JSON格式字符串,然后将其出口到页前边端,以供JavaScript代码分析选用。恐怕你能够直接使用JavaScript代码通过Ajax的办法来读取XML,然后径直对内部的剧情张开分析,这样也许更直接一些。但本文中付出的代码目的在于认证怎样通过原生的C#代码来成功这一改换。除了那一个之外,你如故能够借用一些第三方类库也许越来越高档部分的.NET库对象来实行调换。大家来看看这里介绍的片段较为轻便的主意,但前提是你不能够不持有可支撑的类库和指标以备使用。

图片 1图片 2

Json.NET,提供一对一完整的文档之外,还提供了 LINQ to JSON 的 LINQ Provider 能够更方便人民群众的读取JSON 对象,今后将可比往年用更自在的点子用 .NET编写 JSON 相关的次序了,Json.NET有下列特征:

第二种:利用table拼成JSON数据格式,再用JSON.NET转成JSON输出到前端:

  • 使用Json.NET类库
 1 <head>
 2     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 3     <title></title>
 4     <script type="text/javascript">
 5         var obj = new Object();
 6         obj.Name = "八戒"
 7         obj.Age = 500;
 8 
 9         //通过字面量的形式来定义对象
10         var obj1 = { "Name": "八戒", "Age": "500" };
11         var arr = [{ "Name": "八戒", "Age": "500" }, { "Name": "八戒1", "Age": "1000" }];
12 
13         //JSON格式:将json的字面量表示形式,当做字符串存放,则为json格式字符串
14         var str = '{ "Name": "八戒", "Age": "500" }';
15         var jsonstrarr = '[{ "Name": "八戒", "Age": "500" }, { "Name": "八戒1", "Age": "1000" }];';
16         
17         //将json字符串转换成js对象(数组)
18         var resobj = JSON.parse(str);
19         alert(resobj.Name);
20 
21     </script>
22 </head>
23 <body>
24 </body>
25 </html>
  1. 支持 LINQ to JSON
  2. 支撑Silverlight :Json.NET 提供四个 Newtonsoft.Json.Silverlight.dll  组件,可供 Silverlight 项目步入援用使用
  3. 快速的 JsonReader 与 JsonWriter 对象
  4. 可由此 JsonSerializer 轻巧且高效的转移你现成的 .NET 对象为 JSON 格式(也可从 JSON 格式转回 .NET对象)
  5. Json.NET 也可帮你将 JSON 字符串格式化成有缩排的格式, 方便除错与调度
  6. 可安插 JsonIgnore 与 JsonProperty 属性(Attribute)到您的靶子中,用于指明对象要怎么连串化
  7. 能够将 JSON 转成 XML 格式,也可将 XML 转成 JSON 格式

          

  前提是内需首先下载和安装Json.NET类库,在那能够找到

jsobAndJson

可以从Json.NET CodePlex Project上下载

  dt = new DataTable();

            dt.Columns.Add(new DataColumn("列头",typeof(string)));
            dt.Columns.Add(new DataColumn("object", typeof(object)));

            DataRow dr = dt.NewRow();
            dr[0] = "abc";

            DataTable dt2 = dt.Clone();
            dt2.Columns.Add("defaultdata", typeof(string));
            DataRow dr2 = dt2.NewRow();
            dr2[0] = "defgijk";
            dr2["defaultdata"] = "cccc";
            dt2.Rows.Add(dr2);

            dr[1] = dt2;

            dt.Rows.Add(dr);

            GridView1.DataSource = dt.Rows[0][1];
            GridView1.DataBind();

            Label1.Text = JsonConvert.SerializeObject(dt);

  上面是二个事例:

 在前端js对象和json对象的互转:

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using Newtonsoft.Json;

namespace JSonConverter
{
    class Program
    {
        static void Main(string[] args)
        {
            string xml = "<Test><Name>Test class</Name><X>100</X><Y>200</Y></Test>";

            XmlDocument doc = new XmlDocument();
            doc.LoadXml(xml);
            string json = Newtonsoft.Json.JsonConvert.SerializeXmlNode(doc);

            Console.WriteLine("XML -> JSON: {0}", json);
            Console.ReadLine();

        }
    }
}

一、JS对象转变来为JSON

其三种:用JSON.net自带的JOBJECT,拼成JSON格式,转成JSON在前端输出:

  • 使用.NET Framework中的JavaScriptSerializer.aspx)类

处理:援用多个json2.js文件,调用JSON.stringify()方法。比方:var data = new Object(); var json_data = JSON.stringify(data);

    

  首先必要保障您的工程或服务器扶植.NET 4.0或上述版本的Framework,不然不可能找到此类。

 

JObject obj = new JObject();
    obj.Add(new JProperty("Status", "S"));
    obj.Add(new JProperty("TotalCount", totalCount));
    JArray array = new JArray();
    if (result != null)
    {
    foreach (var item in result)
    {    
    array.Add(
    new JObject(
    new JProperty("X", item.X)
    , new JProperty(" XX", item.XX)
    , new JProperty("XXX", item.XXX)
    , new JProperty("Xxxxx", item.XXXX)
    , new JProperty("xxxxxxx", item.XXXXX)
    , new JProperty("xxxxxxxxx", item.XXXXXX)
    , new JProperty("xxxxxxxxxxx", item.XXXXXXX)
    , new JProperty("xxxxxxxxxxxxx", item.XXXXXXXX)
    , new JProperty("xxxxxxxxxxxxxxxxx", item.XXXXXXXXX)
    , new JProperty("xxxxxxxxxxxxxxxxxxxx", item.XXXXXXXXXX)
    , new JProperty("xxxxxxxxxxxxxxxxxxxxxxx", item.XXXXXXXXXXX)));
    }
    obj.Add(new JProperty("WorkOrderManagerList", array));
    Response.Write(JsonConvert.SerializeObject(obj));

  下边是二个例证:

PS:json2.js以此文件在英特网搜一下就能够下载到。 

 

using System;
using System.Linq;
using System.Web.Script.Serialization;
using System.Xml.Linq;

class Program
{
    static void Main()
    {
        var xml = 
        @"<Columns>
          <Column Name=""key1"" DataType=""Boolean"">True</Column>
          <Column Name=""key2"" DataType=""String"">Hello World</Column>
          <Column Name=""key3"" DataType=""Integer"">999</Column>
        </Columns>";
        var dic = XDocument
            .Parse(xml)
            .Descendants("Column")
            .ToDictionary(
                c => c.Attribute("Name").Value, 
                c => c.Value
            );
        var json = new JavaScriptSerializer().Serialize(dic);
        Console.WriteLine(json);
    }
}

二、JSON转变到为JS

 第多种:利用array数组和hashtable拼成JSON格式,转成JSON在前面二个输出:

  其出口结果为:{"key1":"True","key2":"Hello World","key3":"999"}

1.甩卖:用jQuery的二个艺术$.parseJSON()将JSON格式的数量转成JS对象。举例:var json_data = $.getJSON(); var data = $.parseJSON(json_data); (可用来成转变js数组)

    

  可能还应该有愈来愈多的艺术,这里不一一列出了。那么哪些使用原生的C#代码将XML转变来JSON格式字符串呢?也许说该C#代码在相当的低版本的.NET Framework中也能够运维吧?来探问上面包车型大巴牵线吧。

2.将json转变到js对象的艺术:var json = eval('(' result ')'); 

 ArrayList eventList = new ArrayList();

     Hashtable hx = new Hashtable();
     hx.Add("eventid", 1);
          hx.Add("eventname", "圣诞节");
       hx.Add("eventdate", "2018-08-25");
       hx.Add("eventlocation", "公司会议中心");

       for (int i = 0; i < 3; i  )
      {
      Hashtable ht = new Hashtable();
      ht.Add("eventid", i   1);
      ht.Add("eventname", "圣诞节");
      ht.Add("eventdate", hx);
      ht.Add("eventlocation", "公司会议中心");
      eventList.Add(ht);
     }
    JavaScriptSerializer ser = new JavaScriptSerializer();
    String jsonStr = ser.Serialize(eventList);
    Response.Write(jsonStr);

Introduction

经过地方那么些表明式,就到位了将劳动器端响应给客商端的Json格式的字符串深入分析成了叁个Json(格式的)对象,名叫“json”,通过“json.”也许“json[]”的措施便可进行数量访问。

 

  JSON是二个轻量级的数据调换格式,它能够极度轻松地被页面包车型地铁JavaScript编码为目的的样式,进而有助于数据操作。

 

  基于AJAX的页面使用XmlHttpRequest目的从服务端接收数据来响应客户的伏乞,当再次来到的多少是XML格式时,它能够被转移为JSON格式的字符串进而通过JavaScript越发轻便地对数码实行管理。

在后台对js对象和json对象的互转:

  相当多应用程序都将数据存款和储蓄为XML的格式,况兼会将数据以JSON的格式发送到用户端以做愈来愈管理。要促成这点,它们必得将XML格式转变为JSON格式。下边包车型大巴ASP.NET C#代码落成了这一经过。

 

Code Description

 .NET Framework 4在System.Runtime.Serialization中。利用JavaScript塞里alizer类对数据开展种类化和反系列化

  代码中提供了三个方法XmlToJSON,能够用来将XmlDocument对象转变为JSON字符串。代码通过迭代每三个XML节点、属性以至子节点,来制造对应的JSON对象。

栗子:

  • 代码不会扭转数字和布尔类型的值
  • Xml DocumentElement对象始终会被改造为JSON对象的member:object,它遵守上面那个法则。
  • 节点的性质会被对应地更动为JSON对象的积极分子"attr_name":"attr_value"。如:

    XML JSON
    <xx yy='nn'></xx> { "xx" : { "yy" : "nn" } }
    <xx yy=''></xx> { "xx" : { "yy" : "" } }
  • 从未有过子节点、属性和剧情的节点被改造为成员"child_name":null

    XML JSON
    <xx/> { "xx" : null }
  • 尚无子节点和个性,可是有内容的节点被转移为成员"child_name":"child_text"

    XML JSON
    <xx>yyy</xx> { "xx" : "yyy" }
  • 别的节点和性质会被恰本地转移为"child_name":对象大概"child_name":[elements]指标数组,节点的值会被改换为对象成员的"value",如:

    XML JSON
    <xx yy='nn'><mm>zzz</mm></xx> { "xx" : { "yy" : "nn", "mm" : "zzz" } }
    <xx yy='nn'><mm>zzz</mm><mm>aaa</mm></xx> { "xx" : { "yy" : "nn", "mm" : [ "zzz", "aaa" ] } }
    <xx><mm>zzz</mm>some text</xx> { "xx" : { "mm" : "zzz", "value" : "some text" } }
    <xx value='yyy'>some text<mm>zzz</mm>more text</xx> { "xx" : { "mm" : "zzz", "value" : [ "yyy", "some text", "more text" ] } }
  • 字符会被安全地调换为JSON字符串。注意该调换不会确定保证你的JavaScript代码不会蒙受其余注入攻击,假若中间的内容出自于一段不安全的XML数据源的话。上边那些事例演示了字符的转义:

    XML JSON
    <aa>/z'z''zyyy</aa> { "aa" : "/zu0027z''z\yyy" }
//将param反序列列list集合
List<ApplyPart> _ApplyPart = new JavaScriptSerializer().Deserialize<List<ApplyPart>>(param);

   在少数特殊的条件下,比如下边包车型大巴代码,或许须求你协和对反斜线开展转义。

  

string JSON = XmlToJSON(doc);
JSON = JSON.Replace(@"", @"\");

 

  注意,在页面上选取此外未经济检察查的XML数据时都会设有安全隐患。

Example

XML输入:

<space name="Cake Collage">
<frame>
  <photo img="cakecollage1.jpg" />
  <text string="Browse my cake space" />
  <rule type="F" img="cakecollage9.jpg" x="150" y="0" w="300" h="250" />
  <rule type="F" img="cakecollage2.jpg" x="0" y="0" w="150" h="220" />
</frame>
<frame>
  <photo img="cakecollage2.jpg" />
  <rule type="B" img="cakecollage1.jpg" />
  <rule type="L" img="cakecollage3.jpg" />
</frame>
</space>

JSON输出(对代码举办了格式化):

{ "space":
  { "name": "Cake Collage",
    "frame": [ {"photo": { "img": "cakecollage1.jpg" },
                "rule": [ { "type": "F",
                            "img": "cakecollage9.jpg",
                            "x": "150",
                            "y": "0",
                            "w": "300",
                            "h": "250"
                          }, 
                          { "type": "F",
                            "img": "cakecollage2.jpg",
                            "x": "0",  
                            "y": "0",  
                            "w": "150",  
                            "h": "220" 
                          }
                        ],
                "text": { "string": "Browse my cake space" }
               },
               {"photo": { "img": "cakecollage2.jpg" },
                "rule": [ { "type": "B", "img": "cakecollage1.jpg" },
                          { "type": "L",  "img": "cakecollage3.jpg" }
                        ]
               }
             ]
  }
}

  一旦JSON字符串被定义为一个JavaScript对象,如space_DOM,大家便足以在JavaScript代码中使用下边那一个指标和总体性:

  • space_DOM.space.name
  • space_DOM.space.frame.length
  • space_DOM.space.frame[0].text.string
  • space_DOM.space.frame[0].rule[0].type

  你的JavaScript代码应该能够特别灵活地回应各样气象,如成员子虚乌有、成员只蕴涵value、或成员是二个数组。上面那几个函数可以将装有的积极分子调换到二个数组,进而回答种种差别的气象。

function ObjectToArray( obj)
{
    if( !obj) return new Array();
    if( !obj.length) return new Array(obj);
    return obj;
}

space_DOM.space.frame = ObjectToArray(space_DOM.space.frame);

XmlToJSON C# code

  上面给出对应的C#源代码,通过传播的XmlDocument目的将其改动为相应的JSON格式字符串。

private static string XmlToJSON(XmlDocument xmlDoc)
{
    StringBuilder sbJSON = new StringBuilder();
    sbJSON.Append("{ ");
    XmlToJSONnode(sbJSON, xmlDoc.DocumentElement, true);
    sbJSON.Append("}");
    return sbJSON.ToString();
}

//  XmlToJSONnode:  Output an XmlElement, possibly as part of a higher array
private static void XmlToJSONnode(StringBuilder sbJSON, XmlElement node, bool showNodeName)
{
    if (showNodeName)
        sbJSON.Append("""   SafeJSON(node.Name)   "": ");
    sbJSON.Append("{");
    // Build a sorted list of key-value pairs
    //  where   key is case-sensitive nodeName
    //          value is an ArrayList of string or XmlElement
    //  so that we know whether the nodeName is an array or not.
    SortedList childNodeNames = new SortedList();

    //  Add in all node attributes
    if( node.Attributes!=null)
        foreach (XmlAttribute attr in node.Attributes)
            StoreChildNode(childNodeNames,attr.Name,attr.InnerText);

    //  Add in all nodes
    foreach (XmlNode cnode in node.ChildNodes)
    {
        if (cnode is XmlText)
            StoreChildNode(childNodeNames, "value", cnode.InnerText);
        else if (cnode is XmlElement)
            StoreChildNode(childNodeNames, cnode.Name, cnode);
    }

    // Now output all stored info
    foreach (string childname in childNodeNames.Keys)
    {
        ArrayList alChild = (ArrayList)childNodeNames[childname];
        if (alChild.Count == 1)
            OutputNode(childname, alChild[0], sbJSON, true);
        else
        {
            sbJSON.Append(" ""   SafeJSON(childname)   "": [ ");
            foreach (object Child in alChild)
                OutputNode(childname, Child, sbJSON, false);
            sbJSON.Remove(sbJSON.Length - 2, 2);
            sbJSON.Append(" ], ");
        }
    }
    sbJSON.Remove(sbJSON.Length - 2, 2);
    sbJSON.Append(" }");
}

//  StoreChildNode: Store data associated with each nodeName
//                  so that we know whether the nodeName is an array or not.
private static void StoreChildNode(SortedList childNodeNames, string nodeName, object nodeValue)
{
    // Pre-process contraction of XmlElement-s
    if (nodeValue is XmlElement)
    {
        // Convert  <aa></aa> into "aa":null
        //          <aa>xx</aa> into "aa":"xx"
        XmlNode cnode = (XmlNode)nodeValue;
        if( cnode.Attributes.Count == 0)
        {
            XmlNodeList children = cnode.ChildNodes;
            if( children.Count==0)
                nodeValue = null;
            else if (children.Count == 1 && (children[0] is XmlText))
                nodeValue = ((XmlText)(children[0])).InnerText;
        }
    }
    // Add nodeValue to ArrayList associated with each nodeName
    // If nodeName doesn't exist then add it
    object oValuesAL = childNodeNames[nodeName];
    ArrayList ValuesAL;
    if (oValuesAL == null)
    {
        ValuesAL = new ArrayList();
        childNodeNames[nodeName] = ValuesAL;
    }
    else
        ValuesAL = (ArrayList)oValuesAL;
    ValuesAL.Add(nodeValue);
}

private static void OutputNode(string childname, object alChild, StringBuilder sbJSON, bool showNodeName)
{
    if (alChild == null)
    {
        if (showNodeName)
            sbJSON.Append("""   SafeJSON(childname)   "": ");
        sbJSON.Append("null");
    }
    else if (alChild is string)
    {
        if (showNodeName)
            sbJSON.Append("""   SafeJSON(childname)   "": ");
        string sChild = (string)alChild;
        sChild = sChild.Trim();
        sbJSON.Append("""   SafeJSON(sChild)   """);
    }
    else
        XmlToJSONnode(sbJSON, (XmlElement)alChild, showNodeName);
    sbJSON.Append(", ");
}

// Make a string safe for JSON
private static string SafeJSON(string sIn)
{
    StringBuilder sbOut = new StringBuilder(sIn.Length);
    foreach (char ch in sIn)
    {
        if (Char.IsControl(ch) || ch == ''')
        {
            int ich = (int)ch;
            sbOut.Append(@"u"   ich.ToString("x4"));
            continue;
        }
        else if (ch == '"' || ch == '\' || ch == '/')
        {
            sbOut.Append('\');
        }
        sbOut.Append(ch);
    }
    return sbOut.ToString();
}

Using XmlToJSON

  下边包车型大巴代码演示了怎么样在ASP.NET 2的页面中接纳XmlToJSON()措施。页面上接纳了ClientScriptManager目的来作为JavaScript代码的容器。当然,你完全能够利用其余任何方法将所更改的JSON字符串放到前端页面上。通过下面包车型地铁代码,程序在前端页面上调用四个名称为space_processJSON的JavaScript函数,并将JSON字符串作为参数传递给它。

protected void Page_Load(object sender, EventArgs e)
{
    XmlDocument doc = new XmlDocument();
    try
    {
        string path = Server.MapPath(".");
        doc.Load(path "whatever.xml");
    }
    catch (Exception ex)
    {
        lblError.Text = ex.ToString();
        return;
    }

    // Convert XML to a JSON string
    string JSON = XmlToJSON(doc);

    // Replace  with \ because string is being decoded twice
    JSON = JSON.Replace(@"", @"\");

    // Insert code to process JSON at end of page
    ClientScriptManager cs = Page.ClientScript;
    cs.RegisterStartupScript(GetType(), "SpaceJSON", "space_processJSON('"   JSON   "');", true);
}

  来探视前端页面上定义的这一个JavaScript函数的具体内容。

<script src="space/json.js" type="text/javascript"></script>

<script type="text/javascript">
function space_processJSON( JSON)
{
    space_DOM = JSON.parseJSON();
    if( !space_DOM)
    {
        alert("JSON decode error");
        return;
    }
    space_DOM.space.frame = ObjectToArray(space_DOM.space.frame);
    space_frameCount = space_DOM.space.frame.length;
    //.. or whatever
}
</script>

  原来的小讲出处:《How to convert XML to JSON in ASP.NET C#》

本文由pc28.am发布于计算机编程,转载请注明出处:JS对象与json字符串格式,输出到前端JSON的几种方

上一篇:pc28.am:IDE使用教程,物联网建设中电视发表互联 下一篇:没有了
猜你喜欢
热门排行
精彩图文