用c#写一个json的万能解析器

CommonJsonModel .cs

 /// <summary>
    /// 万能JSON解析器
    /// </summary>
    public class CommonJsonModel : CommonJsonModelAnalyze
    {
        private string rawjson;
        private bool isValue = false;
        private bool isModel = false;
        private bool isCollection = false;
        internal CommonJsonModel(string rawjson)
        {
            this.rawjson = rawjson;
            if (string.IsNullOrEmpty(rawjson))
                throw new Exception("missing rawjson");
            rawjson = rawjson.Trim();
            if (rawjson.StartsWith("{"))
            {
                isModel = true;
            }
            else if (rawjson.StartsWith("["))
            {
                isCollection = true;
            }
            else
            {
                isValue = true;
            }
        }
        public string Rawjson
        {
            get { return rawjson; }
        }
        public bool IsValue()
        {
            return isValue;
        }
        public bool IsValue(string key)
        {
            if (!isModel)
                return false;
            if (string.IsNullOrEmpty(key))
                return false;
            foreach (string subjson in base._GetCollection(this.rawjson))
            {
                CommonJsonModel model = new CommonJsonModel(subjson);
                if (!model.IsValue())
                    continue;
                if (model.Key == key)
                {
                    CommonJsonModel submodel = new CommonJsonModel(model.Value);
                    return submodel.IsValue();
                }
            }
            return false;
        }
        public bool IsModel()
        {
            return isModel;
        }
        public bool IsModel(string key)
        {
            if (!isModel)
                return false;
            if (string.IsNullOrEmpty(key))
                return false;
            foreach (string subjson in base._GetCollection(this.rawjson))
            {
                CommonJsonModel model = new CommonJsonModel(subjson);
                if (!model.IsValue())
                    continue;
                if (model.Key == key)
                {
                    CommonJsonModel submodel = new CommonJsonModel(model.Value);
                    return submodel.IsModel();
                }
            }
            return false;
        }
        public bool IsCollection()
        {
            return isCollection;
        }
        public bool IsCollection(string key)
        {
            if (!isModel)
                return false;
            if (string.IsNullOrEmpty(key))
                return false;
            foreach (string subjson in base._GetCollection(this.rawjson))
            {
                CommonJsonModel model = new CommonJsonModel(subjson);
                if (!model.IsValue())
                    continue;
                if (model.Key == key)
                {
                    CommonJsonModel submodel = new CommonJsonModel(model.Value);
                    return submodel.IsCollection();
                }
            }
            return false;
        }

        /// <summary>
        /// 当模型是对象,返回拥有的key
        /// </summary>
        /// <returns></returns>
        public List<string> GetKeys()
        {
            if (!isModel)
                return null;
            List<string> list = new List<string>();
            foreach (string subjson in base._GetCollection(this.rawjson))
            {
                string key = new CommonJsonModel(subjson).Key;
                if (!string.IsNullOrEmpty(key))
                    list.Add(key);
            }
            return list;
        }
        /// <summary>
        /// 当模型是对象,key对应是值,则返回key对应的值
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public string GetValue(string key)
        {
            if (!isModel)
                return null;
            if (string.IsNullOrEmpty(key))
                return null;
            foreach (string subjson in base._GetCollection(this.rawjson))
            {
                CommonJsonModel model = new CommonJsonModel(subjson);
                if (!model.IsValue())
                    continue;
                if (model.Key == key)
                    return model.Value;
            }
            return null;
        }
        /// <summary>
        /// 模型是对象,key对应是对象,返回key对应的对象
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public CommonJsonModel GetModel(string key)
        {
            if (!isModel)
                return null;
            if (string.IsNullOrEmpty(key))
                return null;
            foreach (string subjson in base._GetCollection(this.rawjson))
            {
                CommonJsonModel model = new CommonJsonModel(subjson);
                if (!model.IsValue())
                    continue;
                if (model.Key == key)
                {
                    CommonJsonModel submodel = new CommonJsonModel(model.Value);
                    if (!submodel.IsModel())
                        return null;
                    else
                        return submodel;
                }
            }
            return null;
        }
        /// <summary>
        /// 模型是对象,key对应是集合,返回集合
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public CommonJsonModel GetCollection(string key)
        {
            if (!isModel)
                return null;
            if (string.IsNullOrEmpty(key))
                return null;
            foreach (string subjson in base._GetCollection(this.rawjson))
            {
                CommonJsonModel model = new CommonJsonModel(subjson);
                if (!model.IsValue())
                    continue;
                if (model.Key == key)
                {
                    CommonJsonModel submodel = new CommonJsonModel(model.Value);
                    if (!submodel.IsCollection())
                        return null;
                    else
                        return submodel;
                }
            }
            return null;
        }
        /// <summary>
        /// 模型是集合,返回自身
        /// </summary>
        /// <returns></returns>
        public List<CommonJsonModel> GetCollection()
        {
            List<CommonJsonModel> list = new List<CommonJsonModel>();
            if (IsValue())
                return list;
            foreach (string subjson in base._GetCollection(rawjson))
            {
                list.Add(new CommonJsonModel(subjson));
            }
            return list;
        }

        /// <summary>
        /// 当模型是值对象,返回key
        /// </summary>
        private string Key
        {
            get
            {
                if (IsValue())
                    return base._GetKey(rawjson);
                return null;
            }
        }
        /// <summary>
        /// 当模型是值对象,返回value
        /// </summary>
        private string Value
        {
            get
            {
                if (!IsValue())
                    return null;
                return base._GetValue(rawjson);
            }
        }
    }

CommonJsonModelAnalyze.cs

public class CommonJsonModelAnalyze
    {
        protected string _GetKey(string rawjson)
        {
            if (string.IsNullOrEmpty(rawjson))
                return rawjson;
            rawjson = rawjson.Trim();
            string[] jsons = rawjson.Split(new char[] { ‘:‘ });
            if (jsons.Length < 2)
                return rawjson;
            return jsons[0].Replace("\"", "").Trim();
        }
        protected string _GetValue(string rawjson)
        {
            if (string.IsNullOrEmpty(rawjson))
                return rawjson;
            rawjson = rawjson.Trim();
            string[] jsons = rawjson.Split(new char[] { ‘:‘ }, StringSplitOptions.RemoveEmptyEntries);
            if (jsons.Length < 2)
                return rawjson;
            StringBuilder builder = new StringBuilder();
            for (int i = 1; i < jsons.Length; i++)
            {
                builder.Append(jsons[i]);
                builder.Append(":");
            }
            if (builder.Length > 0)
                builder.Remove(builder.Length - 1, 1);
            string value = builder.ToString();
            if (value.StartsWith("\""))
                value = value.Substring(1);
            if (value.EndsWith("\""))
                value = value.Substring(0, value.Length - 1);
            return value;
        }
        protected List<string> _GetCollection(string rawjson)
        {
            //[{},{}]
            List<string> list = new List<string>();
            if (string.IsNullOrEmpty(rawjson))
                return list;
            rawjson = rawjson.Trim();
            StringBuilder builder = new StringBuilder();
            int nestlevel = -1;
            int mnestlevel = -1;
            for (int i = 0; i < rawjson.Length; i++)
            {
                if (i == 0)
                    continue;
                else if (i == rawjson.Length - 1)
                    continue;
                char jsonchar = rawjson[i];
                if (jsonchar == ‘{‘)
                {
                    nestlevel++;
                }
                if (jsonchar == ‘}‘)
                {
                    nestlevel--;
                }
                if (jsonchar == ‘[‘)
                {
                    mnestlevel++;
                }
                if (jsonchar == ‘]‘)
                {
                    mnestlevel--;
                }
                if (jsonchar == ‘,‘ && nestlevel == -1 && mnestlevel == -1)
                {
                    list.Add(builder.ToString());
                    builder = new StringBuilder();
                }
                else
                {
                    builder.Append(jsonchar);
                }
            }
            if (builder.Length > 0)
                list.Add(builder.ToString());
            return list;
        }
    }

上面是json的C#的一个解析器,下面是方法的调用

/// <summary>
        /// 引用此方法
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        public static CommonJsonModel DeSerialize(string json)
        {
            return new CommonJsonModel(json);
        }

上面的方法的引用,下面是引用之后的解析实例

/// <summary>
        /// 解析JSON:返回Checking Availability & Pricing
        /// </summary>
        /// <param name="checkAvailabilityJson"></param>
        /// <param name="PickupClass">变量;为空值时返回false</param>
        /// <returns>包含Hotel时获取Itineraries列表</returns>
        public static List<Decode_PickupClassHotelList> GetListHotels(string checkAvailabilityJson, string PickupClass)
        {
            List<Decode_PickupClassHotelList> db_ListHotel = new List<Decode_PickupClassHotelList>();
            CommonJsonModel model = DeSerialize(checkAvailabilityJson);
            //酒店不为空时
            if (PickupClass != "false")
            {
                //是否有就酒店接送的免费服务
                string PickupServiceAvailable=model.GetValue("PickupServiceAvailable");
                if(PickupServiceAvailable.ToLower().Trim().Equals("true"))
                {
                    //获取Hotel酒店列表
                    List<CommonJsonModel> ListHotel = model.GetModel("PickupClassHotelList").GetCollection("" + PickupClass + "").GetCollection();
                    if (ListHotel.Count > 0)
                    {
                        foreach (var p in ListHotel)
                        {
                            Decode_PickupClassHotelList db_model = new Decode_PickupClassHotelList();
                            db_model.id = p.GetValue("id");
                            db_ListHotel.Add(db_model);
                        }
                    }
                 }
            }
            return db_ListHotel;
        }

时间: 2024-10-23 07:10:32

用c#写一个json的万能解析器的相关文章

自己动手写一个编译器Tiny语言解析器实现

然后,上一篇文章简介Tiny词法分析,实现语言.本文将介绍Tiny的语法分析器的实现. 1 Tiny语言的语法 下图是Tiny在BNF中的文法. 文法的定义能够看出.INNY语言有以下特点: 1 程序共同拥有5中语句:if语句,repea语句,read语句,write语法和assign语句. 2 if语句以end作为结束符号,if语句和repeat语句同意语句序列作为主体. 3 输入/输出由保留字read和write開始.read语句一次仅仅读出一个变量,而write语句一次仅仅写出一个表达式.

一起写一个JSON解析器

[本篇博文会介绍JSON解析的原理与实现,并一步一步写出来一个简单但实用的JSON解析器,项目地址:SimpleJSON.希望通过这篇博文,能让我们以后与JSON打交道时更加得心应手.由于个人水平有限,叙述中难免存在不准确或是不清晰的地方,希望大家可以指正:)] 一.JSON解析器介绍 相信大家在平时的开发中没少与JSON打交道,那么我们平常使用的一些JSON解析库都为我们做了哪些工作呢?这里我们以知乎日报API返回的JSON数据来介绍一下两个主流JSON解析库的用法.我们对地址 http://

手写一个json格式化 api

最近写的一个东西需要对json字符串进行格式化然后显示在网页上面. 我就想去网上找找有没有这样的api可以直接调用.百度 json api ,搜索结果都是那种只能在网页上进行校验的工具,没有api. 那只有自己去实现一个json 格式化工具. 仔细分析,实现起来并不是很困难,至少思路很清晰. 需要解决的几个问题: 对json的校验:主要是符号的匹配: 格式化预处理:去除键值对之间的空白字符: 格式化:主要是缩进的问题,要符合json通常展示的格式. 解决的办法: 针对A问题: 可以采用栈去匹配符

从零开始写一个Tomcat(叁)--请求解析

挖坑挖了这么长时间也该继续填坑了,上文书讲到从零开始写一个Tomcat(贰)--建立动态服务器,讲了如何让服务器解析请求,分离servlet请求和静态资源请求,读取静态资源文件输出或是通过URLClassLoader找到我们请求的servlet,反射生成对应的实例,调用其service方法,传递初级解析的request和response,完成请求. 这很tomcat,but too simple 阅读本文,你将了解 连接器(connector),处理器(processor)逻辑分离 如何高效的解

自己DIY出来一个JSON结构化展示器

说来也巧,这个玩意,一直都想亲手写一个,因为一直用着各种网上提供的工具,觉得这个还是有些用途,毕竟,后面的实现思路和原理不是太复杂,就是对json的遍历,然后给予不同节点类型以不同的展现风格. 我这次,是出于将一个专利写清楚,自己构思了一个实现方案,且还能显示出当前的路径,具体的显示风格,依据自己的喜好,随便DIY吧. 写这个JSON展示器,其实有很多用处,不仅仅就是为了看一个json的结构化展示. 1. 更重要的是可以辅助用户和json数据进行交互,能够知道用户感兴趣的json字段是什么,可以

python 写一个计算执行时间的装饰器

面试题之一. 写一个装饰器wraps,它接收一个参数t,如果函数执行时间超过1秒,输出"bad",否则输出"goods". 首先,计算函数的执行时间: import time start = time.clock() for i in range(1000000):     pass end = time.clock() print "cost time = %f s" % (end-start) 结果: >>> cost ti

kotlin 写的一个简单 sql 查询解析器

1 package com.dx.efuwu.core 2 3 import org.apache.commons.lang.StringUtils 4 import java.sql.PreparedStatement 5 6 /** 7 * sql 模板处理 8 * @author sunzq 9 * 2017/06/02 10 */ 11 12 /** 13 * 查询的一个条件句 14 */ 15 class QueryBranch(val content: String, val key

单片机裸机下写一个自己的shell调试器

该文章是针对于串口通讯过程中快速定义命令而写的,算是我自己的一个通用化的平台,专门用来进行串口调试用,莫要取笑 要处理串口数据首先是要对单片机的串口中断进行处理,我的方法是正确的命令必须要在命令的结尾处同时带有回车和换行,处理过程如下 //串口接收缓冲区 u8 serial_Buffer[SERIAL_MAX_LENGTH] = {0}; //串口接收数据长度 u16 serial_Buffer_Length = 0; static void SerialRecv(u8 ch) { if((se

如何写一个正经的音乐播放器 四 意外情况

四,意外情况的控制. 在音频播放时候,容易遇到一些意外情况,这时候,我们就要处理这些意外情况,这时候,我们需要针对不同的意外情况进行处理.大概可以分成两种情况. 1,失去audio_focus的控制. 造成我们的播放器失去焦点的情况很多,主要是其他声音请求了焦点,例如说,其他音乐播放器开始播放音乐,突然来电,短息等. 以上的焦点失去,都可以用AudioManager.OnAudioFocusChangeListener中的回调来处理.先取得AudioManager AudioManager au