C# JsonObject Json格式与Json对象相互转换

最新推荐文章于 2025-06-25 10:48:26 发布
最新推荐文章于 2025-06-25 10:48:26 发布
阅读量8k 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： C# 文章标签： json c# parse
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/leedoom/article/details/17118171
本文介绍了一个使用C#编写的JsonObject类库，用于Json格式与Json对象之间的转换。JsonObject类提供了添加键值对的方法，并支持String、Array、Integer及Json对象类型。此外，还提供了Parse方法将Json字符串解析成Json对象，以及ToString方法将Json对象转换回字符串。通过示例代码展示了如何使用该类库进行转换操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;


/// JsonObject leedoom@qq.com
namespace JsonObject
{
    public enum JsonItemType
    {
        String,
        Array,
        Integer,
        Node
    }

    public sealed class Json
    {
        #region -- Private Fields --
        private IList<JsonItem> _col;
        private int _deep = 0;
        private Json _parent;
        #endregion

        #region -- Methods --
        public Json()
        {
            this._col = new List<JsonItem>();
        }
        public void Add(string key, string value)
        {
            if (key == null || key == "" || value == null) throw new ArgumentException("键值不能为空,参数不能为null");
            JsonItem si = new JsonItem();
            si.ItemType = JsonItemType.String;
            si.Key = key;
            si.Value = value;
            this._col.Add(si);
        }
        public void Add(string key, int value)
        {
            if (key == null || key == "") throw new ArgumentException("键值不能为空,参数不能为null");
            JsonItem si = new JsonItem();
            si.ItemType = JsonItemType.Integer;
            si.Key = key;
            si.Value = value;
            this._col.Add(si);
        }
        public void Add(string key, IList<object> value)
        {
            if (key == null || key == "" || value == null) throw new ArgumentException("键值不能为空,参数不能为null");
            JsonItem si = new JsonItem();
            si.ItemType = JsonItemType.Array;
            si.Key = key;
            si.Value = value;
            this._col.Add(si);
        }
        public void Add(string key, Json value)
        {
            if (key == null || key == "" || value == null) throw new ArgumentException("键值不能为空,参数不能为null");
            JsonItem si = new JsonItem();
            si.ItemType = JsonItemType.Node;
            si.Key = key;
            si.Value = value;
            this._col.Add(si);
        }
        public override string ToString()
        {
            return new JsonConvert.Writer(this).ToString();
        }
        public static Json Parse(string jsonString)
        {
            return new JsonConvert.Reader(jsonString).ToJson();

        }
        #endregion

        #region -- Properties --
        public int Length
        {
            get { return this._col.Count; }
        }
        public Jszn this[string key]
        {
            get
            {
                foreach (JsonItem si in this._col)
                {
                    if (si.Key == key)
                    {
                        return new Jszn(si);
                    }
                }
                throw new ArgumentException("没有找到Key为 " + key + " 的数据序列");
            }
        }
        internal JsonItem this[int index]
        {
            get
            {
                return (JsonItem)this._col[index];
            }
        }
        public int Deep
        {
            get { return this._deep; }
            set { this._deep = value; }
        }
        public Json Parent
        {
            get { return this._parent; }
            set { this._parent = value; }
        }
        #endregion
    }

    public sealed class Jszn
    {
        #region -- Private Fields --
        JsonItem _item;
        #endregion

        #region -- Method --
        public Jszn(JsonItem item)
        {
            this._item = item;
        }
        public override string ToString()
        {
            return this._item.Value.ToString();
        }
        public int ToInt()
        {
            if (this._item.ItemType == JsonItemType.Integer)
            {
                return Convert.ToInt32(this._item.Value);
            }
            else
            {
                throw new ArgumentOutOfRangeException("该返回数据类型不应为数字整型 Integer");
            }
        }
        public string[] ToArray()
        {
            if (this._item.ItemType == JsonItemType.Array)
            {
                return (string[])this._item.Value;
            }
            else
            {
                throw new ArgumentOutOfRangeException("该返回数据类型不应为数组型 Array");
            }
        }
        #endregion

        #region -- Properties --
        public Jszn this[string key]
        {
            get
            {
                if (this._item.ItemType == JsonItemType.Node)
                {
                    Json json = (Json)this._item.Value;
                    return json[key];
                }
                else
                {
                    throw new ArgumentOutOfRangeException("该返回数据类型不应为数据节点类型 Node");
                }
            }
        }
        public Jszn this[int index]
        {
            get
            {
                if (this._item.ItemType == JsonItemType.Array)
                {
                    IList<object> result = (IList<object>)this._item.Value;
                    if (result[index].GetType() == typeof(System.String))
                    {
                        JsonItem ji = new JsonItem();
                        ji.ItemType = JsonItemType.String;
                        ji.Key = "";
                        ji.Value = result[index];
                        return new Jszn(ji);
                    }
                    else if (result[index].GetType() == typeof(System.Collections.Generic.List<object>))
                    {
                        JsonItem ji = new JsonItem();
                        ji.ItemType = JsonItemType.Array;
                        ji.Key = "";
                        ji.Value = result[index];
                        return new Jszn(ji);
                    }
                    else if (result[index].GetType() == typeof(System.Int32))
                    {
                        JsonItem ji = new JsonItem();
                        ji.ItemType = JsonItemType.Integer;
                        ji.Key = "";
                        ji.Value = result[index];
                        return new Jszn(ji);
                    }
                    else if (result[index].GetType() == typeof(JsonObject.Json))
                    {
                        JsonItem ji = new JsonItem();
                        ji.ItemType = JsonItemType.Node;
                        ji.Key = "";
                        ji.Value = result[index];
                        return new Jszn(ji);
                    }
                    else
                    {
                        throw new Exception("未知的返回类型!");
                    }
                }
                else
                {
                    throw new ArgumentOutOfRangeException("该返回数据类型不应为数组类型 Array");
                }
            }
        }
        #endregion
    }

    public class JsonItem
    {
        #region -- Privtae Fields --
        private string _key;
        private JsonItemType _itemType;
        private object _value;
        #endregion

        #region -- Properties --
        public string Key
        {
            get { return this._key; }
            set { this._key = value; }
        }
        public JsonItemType ItemType
        {
            get { return this._itemType; }
            set { this._itemType = value; }
        }
        public object Value
        {
            get { return this._value; }
            set { this._value = value; }
        }
        #endregion
    }

    public sealed class JsonConvert
    {
        public sealed class Reader
        {
            #region -- Privtae Fields --
            private string _xml;
            private int current;
            #endregion

            #region -- Method --
            public Reader(string Xml)
            {
                this._xml = Xml;
                this.current = 0;
            }
            public Json ToJson()
            {
                return EnumKey();
            }
            private Json EnumKey()
            {
                bool dump = false, enumKey = true;
                string sKey = "", sValue = "";
                IList<object> aValue;
                int iValue = 0;
                int KeyEnd = 0, KeyStart = 0, KeyCount = 0;
                Json json = new Json();
                if (this._xml[current] == '{')
                {
                    this.Plus();
                    this.Skip();
                    while (enumKey)
                    {
                        #region  -- 取得Key --
                        if (this._xml[current] != '"') break;
                        this.Plus();
                        KeyStart = current;
                        dump = false;
                        while (!dump)
                        {
                            while (this._xml[current] != '"')
                            {
                                current++;
                            }
                            if (this._xml[current - 1] != '\\')
                            {
                                dump = true;
                            }
                        }
                        KeyEnd = current;
                        KeyCount = KeyEnd - KeyStart;
                        sKey = this.Read(KeyStart, KeyCount);
                        this.Plus();
                        #endregion
                        #region -- Key Value 分割 --
                        if (this._xml[current] != ':')
                        {
                            if (this._xml[current] != ' ')
                            {
                                this.Skip();
                                if (this._xml[current] != ':')
                                {
                                    break;
                                }
                                else
                                {
                                    this.Plus();
                                    this.Skip();
                                }
                            }
                            else
                            {
                                break;
                            }
                        }
                        else
                        {
                            this.Plus();
                            this.Skip();
                        }
                        #endregion
                        #region -- 字符型Value --
                        if (this._xml[current] == '"')
                        {
                            this.Plus();
                            KeyStart = current;
                            dump = false;
                            while (!dump)
                            {
                                while (this._xml[current] != '"')
                                {
                                    this.Plus();
                                }
                                if (this._xml[current - 1] != '\\')
                                {
                                    dump = true;
                                }
                            }
                            KeyEnd = current;
                            KeyCount = KeyEnd - KeyStart;
                            sValue = this.Read(KeyStart, KeyCount);
                            json.Add(sKey, sValue);
                            this.Plus();
                        }
                        #endregion
                        #region -- 数组型Value --
                        else if (this._xml[current] == '[')
                        {
                            aValue = EnumList();
                            json.Add(sKey, aValue);
                        }
                        #endregion
                        #region -- 节点型Value --
                        else if (this._xml[current] == '{')
                        {
                            Json sJson = EnumKey();
                            json.Add(sKey, sJson);
                        }
                        #endregion
                        #region -- 整数型Value --
                        else
                        {
                            KeyStart = current;
                            while (this._xml[current] != ',' && this._xml[current] != '}')
                            {
                                this.Plus();
                            }
                            KeyEnd = current;
                            KeyCount = KeyEnd - KeyStart;
                            try
                            {
                                iValue = Convert.ToInt32(this.Read(KeyStart, KeyCount));
                            }
                            catch
                            {
                                break;
                            }
                            json.Add(sKey, iValue);
                        }
                        #endregion
                        #region -- 判断结束符 --
                        this.Skip();
                        if (this._xml[current] == ',')
                        {
                            this.Plus();
                            this.Skip();
                        }
                        else if (this._xml[current] == '}')
                        {
                            enumKey = false;
                            this.Plus();
                            this.Skip();
                        }
                        else
                        {
                            break;
                        }
                        #endregion
                    }
                }
                return json;
            }
            private IList<object> EnumList()
            {
                bool dump = false, enumKey = true;
                string sValue = "";
                IList<object> subValue = new List<object>(), aValue;
                int iValue = 0;
                int KeyEnd = 0, KeyStart = 0, KeyCount = 0;
                if (this._xml[current] == '[')
                {
                    this.Plus();
                    this.Skip();
                    while (enumKey)
                    {
                        #region -- 字符型Value --
                        if (this._xml[current] == '"')
                        {
                            this.Plus();
                            KeyStart = current;
                            dump = false;
                            while (!dump)
                            {
                                while (this._xml[current] != '"')
                                {
                                    this.Plus();
                                }
                                if (this._xml[current - 1] != '\\')
                                {
                                    dump = true;
                                }
                            }
                            KeyEnd = current;
                            KeyCount = KeyEnd - KeyStart;
                            sValue = this.Read(KeyStart, KeyCount);
                            subValue.Add(sValue);
                            this.Plus();
                        }
                        #endregion
                        #region -- 数组型Value --
                        else if (this._xml[current] == '[')
                        {
                            aValue = EnumList();
                            subValue.Add(aValue);
                        }
                        #endregion
                        #region -- 节点型Value --
                        else if (this._xml[current] == '{')
                        {
                            Json sJson = EnumKey();
                            subValue.Add(sJson);
                        }
                        #endregion
                        #region -- 整数型Value --
                        else
                        {
                            KeyStart = current;
                            while (this._xml[current] != ',' && this._xml[current] != ']')
                            {
                                this.Plus();
                            }
                            KeyEnd = current;
                            KeyCount = KeyEnd - KeyStart;
                            try
                            {
                                iValue = Convert.ToInt32(this.Read(KeyStart, KeyCount));
                            }
                            catch
                            {
                                break;
                            }
                            subValue.Add(iValue);
                        }
                        #endregion
                        #region -- 判断结束符 --
                        this.Skip();
                        if (this._xml[current] == ',')
                        {
                            this.Plus();
                            this.Skip();
                        }
                        else if (this._xml[current] == ']')
                        {
                            enumKey = false;
                            this.Plus();
                            this.Skip();
                        }
                        else
                        {
                            break;
                        }
                        #endregion
                    }
                }
                return subValue;
            }
            private void Plus()
            {
                this.current++;
            }
            private void Plus(int count)
            {
                this.current += count;
            }
            private void Skip()
            {
                while (current < this._xml.Length && (this._xml[current].ToString() == " " || this._xml[current].ToString() == "\r" || this._xml[current].ToString() == "\n"))
                {
                    current++;
                }
            }
            private string Read(int start, int count)
            {
                return this._xml.Substring(start, count);
            }
            #endregion
        }
        public sealed class Writer
        {
            #region -- Private Fields --
            private Json _json;
            #endregion

            #region -- Method --
            public Writer(Json json)
            {
                this._json = json;
            }
            public override string ToString()
            {
                return EnumKey(this._json);
            }
            private string EnumKey(Json j)
            {
                string result = "{";
                for (int i = 0; i < j.Length; i++)
                {
                    JsonItem ji = j[i];
                    result += "\"" + ji.Key + "\":";
                    if (ji.ItemType == JsonItemType.Array)
                    {
                         result += EnumList((IList<object>)ji.Value);
                    }
                    else if (ji.ItemType == JsonItemType.Integer)
                    {
                        result += ji.Value;
                    }
                    else if (ji.ItemType == JsonItemType.String)
                    {
                        result += "\"" + ji.Value + "\"";
                    }
                    else if (ji.ItemType == JsonItemType.Node)
                    {
                        result += EnumKey((Json)ji.Value);
                    }
                    if (i < j.Length - 1) result += ",";
                }
                result += "}";
                return result;
            }
            private string EnumList(IList<object> l)
            {
                string result = "[";
                for (int i = 0; i < l.Count; i++)
                {
                    if (l[i].GetType() == typeof(System.Collections.Generic.List<object>))
                    {
                        result += EnumList((IList<object>)l[i]);
                    }
                    else if (l[i].GetType() == typeof(System.Int32))
                    {
                        result += l[i].ToString();
                    }
                    else if (l[i].GetType() == typeof(System.String))
                    {
                        result += "\"" + l[i].ToString() + "\"";
                    }
                    else if (l[i].GetType() == typeof(JsonObject.Json))
                    {
                        result += EnumKey((Json)l[i]);
                    }
                    if (i < l.Count - 1) result += ",";
                }
                result += "]";
                return result;
            }
            #endregion
        }
    }
}

string s = "{\r\n" + 
                            "\"name\":\"Bill Gates\",\r\n"+
                            "\"street\":\"Fifth Avenue New York 666\",\r\n"+
                            "\"age\":56,\r\n"+
                            "\"phone\":\"555 1234567\",\r\n"+
                            "\"arr\":[\"thomas\",\"eric\",[\"alice\",\"alex\",{\"gender\":\"female\"}]],\"sub\":{\"a\":1,\"b\":\"2\"}}";
            //将json格式转化为json对象
            JsonObject.Json json = new JsonObject.JsonConvert.Reader(s).ToJson();
            MessageBox.Show(json["name"].ToString());
            MessageBox.Show(json["arr"][0].ToString());
            MessageBox.Show(json["arr"][2][0].ToString());
            MessageBox.Show(json["arr"][2][2]["gender"].ToString());
            MessageBox.Show(json["sub"]["a"].ToString());
            //将json对象转化为json格式
            MessageBox.Show(json.ToString());
在C#中使用JSON
R3333355726856的博客
09-24 9438
在C#中使用JSON
C#解析JSON
我是菜鸟
03-01 6349
string jsonText = "{\"name\":\"网站\",\"num\":2,\"sites\":[{\"name\":\"Google\",\"info\":[\"Android\",\"Google搜索\",\"Google翻译\"]},{\"name\":\"Taobao\",\"info\":[\"淘宝\",\"网购\"]}]}";string jsonText = "{\"allname\":{\"name\":\"张三\",\"name_en\":\"zhangsan\"}}";
JsonObject C#轻量级Json对象转换类
12-04
简单的Json转化类，Json格式与Json对象之间互相转换。 示例:(文件内附示例) string s = "{\r\n" + "\"name\":\"Bill Gates\",\r\n"+ "\"street\":\"Fifth Avenue New York 666\",\r\n"+ "\"age\":56,\r\n"+ "\"phone\":\"555 1234567\",\r\n"+ "\"arr\":[\"thomas\",\"eric\",[\"alice\",\"alex\",{\"gender\":\"female\"}]],\"sub\":{\"a\":1,\"b\":\"2\"}}"; //将json格式转化为json对象 JsonObject.Json json = new JsonObject.JsonConvert.Reader(s).ToJson(); MessageBox.Show(json["name"].ToString()); MessageBox.Show(json["arr"][0].ToString()); MessageBox.Show(json["arr"][2][0].ToString()); MessageBox.Show(json["arr"][2][2]["gender"].ToString()); MessageBox.Show(json["sub"]["a"].ToString()); //将json对象转化为json格式 MessageBox.Show(json.ToString());
C# Json转对象（object）
weixin_44226526的博客
02-06 9636
格式转换 json转object
C# 对象与JSON字符串互相转换的三种方式
最新发布
u014090257的博客
06-25 627
5 Console.WriteLine("============方法一============================================");16 Console.WriteLine("============方法二============================================");8 Console.WriteLine("方法一对象转Json字符串");
JsonObject
06-06
引用using Xfrog.Net; 用法如： JsonObject newObj = new JsonObject("json字符串"); String errorCode = newObj["error_code"].Value;//获取其中的属性值。
C# 操作 JSON
Major_S的博客
02-29 1585
实例：基于X86的Linux系统调用机制简介
C#实现JSON和对象之间互相转换功能示例
08-29
本文主要介绍了C#实现JSON和对象之间互相转换功能，结合实例形式较为详细的分析了C#实现对象与json之间相互转换的操作技巧。 在C#中，实现JSON和对象之间互相转换功能主要使用了DataContract和DataMember两个特性，...
C# 获取json字段中指定值
02-11
在C#编程中，处理JSON数据是常见的任务，特别是在与Web服务交互或处理API响应时。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，因其易读易写而被广泛采用。在这个场景中，我们将关注如何使用C#和...
JSONObject解析json，C# asp.net JSON解析 com.force.json
11-10
在IT行业中，JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，广泛应用于Web服务与客户端之间的数据传输。C#和ASP.NET是Microsoft开发的编程语言和框架，它们提供了丰富的支持来处理JSON数据，包括...
Json数据格式协议C#解析方法
01-03
3. **序列化数组数据**：将对象转换为JSON格式的数据。 - `var`变量类型自定义，根据右值的类型决定。 4. **将Json数据转为数组**：反序列化JSON数据为数组对象。 - `DataContractJsonSerializer`使用同一方法...
全面掌握C#的JObject类：C#开发之JSON数据解析与操作实战指南
编程技术探索者，分享C/C++、C#、Java、数据库等开发经验，聚焦实战技巧与AI兴趣，助力编程爱好者成长。
11-16 1万+
全面掌握C#的JObject类：C#开发之JSON数据解析与操作实战指南
JsonObject（可将json字符串格式转化为json对象或数组）
01-23
顶部添加引用using Xfrog.Net; 用法如： JsonObject newObj1 = new JsonObject("json字符串"); String errorCode = newObj1["error_code"].Value;//获取其中的属性值。 string status = newObj1["result"]["status"].Value;
[C#]JSONObject解析json，C# asp.net JSON解析
热门推荐
天下武功唯CODING不破
01-25 3万+
前言：公司最近遇到问题，以往C#的接口通讯都是走xml的形式，因为现在的主流接口都采用json数据格式，但c#中并没有提供特别的方法帮助开发者，解析和生成都非常麻烦，我做为一个移动端开发者，于是想到了将java的解析方法移植到c#中去，漫长的移植工作开始了，经过一段时间的努力，再加上原本就有一些C#基础的我来说，改起来还是很轻松的，在java中的很多api在c#中都没有，于是乎，找类似方法进行替代
C# JSON转化
wszde2的博客
03-22 497
C# 对象转JSON，效率是系统自带的转化器的十倍，每次转换提供回调函数，可自定义转化结果，回调函数提供路径、属性和字段，可对转化的属性和字段进行特性查找，可对返回数据劫持。一般用于返回加密 public class ActionJson { public class CryptPath { public string ...
C# 对象转Json和Json转对象
菜鸟的专栏
12-03 727
C# 对象转Json和Json转对象
c# 对象json互相转换_C# json与对象之间的相互转换
weixin_33318791的博客
01-14 1233
1. 添加命名空间using System.Runtime.Serialization.Json;2.WriteObject方法// 从一个对象信息生成Json串public static string ObjectToJson(object obj){DataContractJsonSerializer serializer = new DataContractJsonSerializer(o...
C# json 转换
刘欢的博客
04-29 876
public class ConvertJson { #region 私有方法 /// <summary> /// 过滤特殊字符 /// </summary> private static string String2Json(String s) { ...
C#中JSON解析与生成的实现及Java JSONObject的移植方法
解析JSON是指将JSON格式的字符串转换为C#中的对象。使用Newtonsoft.Json库时，可以这样做： #### 2.1 解析JSON字符串为JObject对象 ```csharp using Newtonsoft.Json.Linq; string jsonString = @"{""name"":"...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值