欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

json格式数据分析工具PageElement类分享(仿Session写法)

程序员文章站 2024-02-23 19:10:16
测试例:复制代码 代码如下:pageelement pe = new pageelement();pe.loaddatafromjsonstring("[{\"a\":\"...

测试例:

复制代码 代码如下:

pageelement pe = new pageelement();
pe.loaddatafromjsonstring("[{\"a\":\"123\",\"b\":\"abc\"}]");
console.writeline(pe["a"]); --输出123
pe["b"]=1000;
console.writeline(pe["b"]); --输出1000

pe.datatable:获取数据的 datatable 形式
pe.toinsertsql 转sql insert语句
pe.toupdatesql 转sql update语句

复制代码 代码如下:

namespace mylib.itsm.base
{
    using system;
    using system.collections.generic;
    using system.xml;
    using system.data;
    using system.data.common;
    using system.data.sqlclient;

    public class pageelement : idictionary<string, object>
    {
        public list<keyvaluepair<string, object>> list = new list<keyvaluepair<string, object>>();

        public pageelement() { }

        public pageelement(string xmlstring)
        {
            loadelementfromxmlstring(xmlstring);
        }

        /// <summary>
        /// json属性
        /// </summary>
        public string json
        {
            get
            {
                if (list == null || list.count == 0) return string.empty;
                {
                    string jsonstr = "{";
                    foreach (keyvaluepair<string, object> p in list)
                    {
                        jsonstr += p.key + ":" + "\"" + p.value.tostring() + "\",";
                    }
                    jsonstr = jsonstr.substring(0, jsonstr.length - 1);//去除最后一个逗号
                    jsonstr += "}";
                    return jsonstr;
                }
            }
        }

        /// <summary>
        /// 是否已加载数据
        /// </summary>
        private bool _isloaded = false;
        public bool isloaded
        {
            get
            {
                return _isloaded;
            }
        }

        #region idictionary<string,object> 成员

        void idictionary<string, object>.add(string key, object value)
        {
            //key已存在,则不添加
            foreach (keyvaluepair<string, object> k in list)
            {
                if (k.key == key.trim() || k.key.tolowerinvariant() == key.tolowerinvariant().trim())
                {
                    return;
                }
            }
            //向list中添加
            list.add(new keyvaluepair<string, object>(key, value));
        }

        public bool containskey(string key)
        {
            foreach (keyvaluepair<string, object> k in list)
            {
                if (k.key == key.trim() || k.key.tolowerinvariant() == key.tolowerinvariant().trim())
                {
                    return true;
                }
            }
            return false;
        }

        public icollection<string> keys
        {
            get
            {
                string[] ks = new string[list.count];
                for (int i = 0; i < list.count; i++)
                {
                    ks[i] = list[i].key;
                }
                return ks;
            }
        }

        public bool remove(string key)
        {
            foreach (keyvaluepair<string, object> k in list)
            {
                if (k.key == key.trim() || k.key.tolowerinvariant() == key.tolowerinvariant().trim())
                {
                    list.remove(k);
                    return true;
                }
            }
            return false;
        }

        public bool trygetvalue(string key, out object value)
        {
            foreach (keyvaluepair<string, object> k in list)
            {
                if (k.key == key.trim() || k.key.tolowerinvariant() == key.tolowerinvariant().trim())
                {
                    value = k.value;
                    return true;
                }
            }
            value = string.empty;
            return false;
        }

        public icollection<object> values
        {
            get
            {
                object[] vs = new object[list.count];
                for (int i = 0; i < list.count; i++)
                {
                    vs[i] = list[i].value;
                }
                return vs;
            }
        }

        public object this[string key]
        {
            get
            {
                foreach (keyvaluepair<string, object> k in list)
                {
                    if (k.key == key.trim() || k.key.tolowerinvariant() == key.tolowerinvariant().trim())
                    {
                        return k.value;
                    }
                }
                return null;
            }
            set
            {
                foreach (keyvaluepair<string, object> k in list)
                {
                    if (k.key == key.trim() || k.key.tolowerinvariant() == key.tolowerinvariant().trim())
                    {
                        list.remove(k);//删除原节点
                        break;
                    }
                }
                keyvaluepair<string, object> knew = new keyvaluepair<string, object>(key, value);
                list.add(knew);
            }
        }

        public object this[int index]
        {
            get
            {
                if (index <= list.count)
                {
                    return list[index].value;
                }
                return null;
            }
            set
            {
                string key;
                if (index <= list.count)
                {
                    key = list[index].key.tostring();
                    list.removeat(index);
                    keyvaluepair<string, object> knew = new keyvaluepair<string, object>(key, value);
                    list.insert(index, knew);
                }
            }
        }

        #endregion

        #region icollection<keyvaluepair<string,string>> 成员

        public void add(keyvaluepair<string, object> item)
        {
            throw new notimplementedexception();
        }

        public void clear()
        {
            list = new list<keyvaluepair<string, object>>();
        }

        public bool contains(keyvaluepair<string, object> item)
        {
            foreach (keyvaluepair<string, object> k in list)
            {
                if (k.key == item.key)
                {
                    return true;
                }
            }
            return false;
        }

        public void copyto(keyvaluepair<string, object>[] array, int arrayindex)
        {
            throw new notimplementedexception();
        }

        public int count
        {
            get { return list.count; }
        }

        public bool isreadonly
        {
            get { throw new notimplementedexception(); }
        }

        public bool remove(keyvaluepair<string, object> item)
        {
            foreach (keyvaluepair<string, object> k in list)
            {
                if (k.key == item.key)
                {
                    list.remove(k);
                    return true;
                }
            }
            return false;
        }

        #endregion

        #region ienumerable<keyvaluepair<string,string>> 成员

        public ienumerator<keyvaluepair<string, object>> getenumerator()
        {
            return list.getenumerator();
        }

        #endregion

        #region ienumerable 成员

        system.collections.ienumerator system.collections.ienumerable.getenumerator()
        {
            return list.getenumerator();
        }

        #endregion

        public override string tostring()
        {
            return json;
        }

        /// <summary>
        /// 转为fieldvalue值
        /// </summary>
        /// <returns></returns>
        public xmldocument getxmlobject()
        {
            //fieldvalues fvs = new fieldvalues();
            //foreach (keyvaluepair<string, object> p in list)
            //{
            //    fvs.add(p.key, p.value.tostring());
            //}
            //return fvs.getxmlobject();
            return null;
        }

        /// <summary>
        /// 从xml中载入页面元素数据
        /// </summary>
        /// <param name="xmlstr"></param>
        public void loadelementfromxmlstring(string xmlstr)
        {
            _isloaded = false;
            //try
            //{
            //    fieldvalues fvs = new fieldvalues(xmlstr);
            //    foreach (fieldvalue fv in fvs)
            //    {
            //        this[fv.id] = fv.value;
            //    }
            //}
            //catch { return; }
            _isloaded = true;
        }

        /// <summary>
        /// 从datatable中载入页面元素数据
        /// </summary>
        /// <param name="xmlstr"></param>
        public void loadelementfromdatatable(datatable dt)
        {
            _isloaded = false;
            try
            {
                if (dt != null)
                {
                    foreach (datarow row in dt.rows)
                    {
                        //遍历行
                        foreach (datacolumn dc in dt.columns)
                        {
                            this[dc.columnname] = row[dc];
                        }
                    }
                }
            }
            catch { return; }
            _isloaded = true;
        }
        /// <summary>
        /// 从json中载入页面元素数据
        /// </summary>
        /// <param name="xmlstr"></param>
        public void loadelementfromjsonstring(string json)
        {
            _isloaded = false;
            try
            {
                list<string> jslist = getfieldsstring(json);
                //生成列
                foreach (string s in jslist)
                {
                    string[] keyvalueseparator = { ":" };
                    string key = s.substring(0, s.indexof(':')).trim();
                    string value = s.substring(s.indexof(':') + 1).trim();
                    if (key.trim().startswith("\"") && key.trim().endswith("\""))
                    {
                        //去除多余的双引号
                        int end = key.length - 2;
                        key = key.substring(1, end);
                    }
                    if (value.trim().startswith("\"") && value.trim().endswith("\""))
                    {
                        //去除多余的双引号
                        int end = value.length - 2;
                        value = value.substring(1, end);
                        //pageelement类型的内容
                        if (value.startswith("{") && value.endswith("}"))
                        {
                            value = value.replace("\\", string.empty);//祛除多余转义符
                            pageelement pechild = new pageelement();
                            pechild.loadelementfromjsonstring(value);
                            this[key] = pechild;
                        }
                        else  //普通类型的内容解析
                        {
                            //若列值存在
                            this[key] = converttogb(value);
                        }
                    }
                }
            }
            catch
            {
                return;
            }
            _isloaded = true;
        }

        /// <summary>  
        /// 把unicode解码为普通文字  
        /// </summary>  
        /// <param name="unicodestring">要解码的unicode字符集</param>  
        /// <returns>解码后的字符串</returns>  
        private string converttogb(string unicodestring)
        {
            string[] strarray = unicodestring.split(new string[] { @"\u" }, stringsplitoptions.none);
            string result = string.empty;
            for (int i = 0; i < strarray.length; i++)
            {
                if (strarray[i].trim() == "" || strarray[i].length < 2 || strarray.length <= 1)
                {
                    result += i == 0 ? strarray[i] : @"\u" + strarray[i];
                    continue;
                }
                for (int j = strarray[i].length > 4 ? 4 : strarray[i].length; j >= 2; j--)
                {
                    try
                    {
                        result += char.convertfromutf32(convert.toint32(strarray[i].substring(0, j), 16)) + strarray[i].substring(j);
                        break;
                    }
                    catch
                    {
                        continue;
                    }
                }
            }
            return result;
        }

        /// <summary>
        /// 获取字段json字符串
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        private list<string> getfieldsstring(string jsons)
        {
            list<string> retfieldsstring = new list<string>();
            if (jsons == string.empty)
                return retfieldsstring;
            string json = jsons.trim();
            //祛除首尾
            if (json.startswith("[") && json.endswith("]"))
            {
                int length = json.length - 2;
                json = json.substring(1, length);
            }

            //是json格式的字串,以{开头,以}结尾
            if (json.startswith("{") && json.endswith("}"))
            {
                int jsonlength = json.length - 1;
                string str = json.substring(1, jsonlength - 1) + ",";
                //祛除头尾的"{","}"
                int startpos = 0; //搜索开始的位置指针
                int length = 0;  //搜索结束的位置指针
                int flagcount = 0; //对象开始字符的个数,根据此个数排除结束标志
                //遍历得到内部字符串
                while (startpos + length < str.length)  //未搜索完成,则继续搜索
                {
                    if (str[startpos + length] == '{')
                    {
                        flagcount += 1;
                    }
                    else if (str[startpos + length] == '}')
                    {
                        if (flagcount > 0)  //若开始字符的个数不等于0,则字符中间存在对象,应将标志位减1并且排除
                        {
                            flagcount -= 1;
                        }
                    }
                    else if (str[startpos + length] == ',')
                    {
                        if (flagcount == 0)
                        {
                            retfieldsstring.add(str.substring(startpos, length));
                            startpos = startpos + length + 1;//新的起始位置
                            length = 0; //新的截取长度
                        }
                    }
                    length += 1; //末尾指针加1,进入下一次循环的搜索
                }
                return retfieldsstring;
            }
            return retfieldsstring;
        }

        /// <summary>
        /// 转为sql insert 语句
        /// </summary>
        /// <param name="tablename"></param>
        /// <returns></returns>
        public string toinsertsql(string tablename)
        {
            string sql = @"insert into " + tablename + "(";
            string fields = string.empty;
            string values = string.empty;
            foreach (keyvaluepair<string, object> p in list)
            {
                fields += p.key + ",";
                //values += stringtool.sqlq(p.value.tostring()) + ",";
            }
            fields = fields.substring(0, fields.length - 1);//去除最后一个逗号
            values = values.substring(0, values.length - 1);//去除最后一个逗号
            sql += fields + ") values (" + values + ")";
            return sql;
        }

        /// <summary>
        /// 转为sql update 语句
        /// </summary>
        /// <param name="tablename"></param>
        /// <returns></returns>
        public string toupdatesql(string tablename, string wherefield)
        {
            string sql = @"update " + tablename + " set ";
            foreach (keyvaluepair<string, object> p in list)
            {
                //sql += p.key + " = " + stringtool.sqlq(p.value.tostring()) + ",";
            }
            sql = sql.substring(0, sql.length - 1);//去除最后一个逗号
            //sql += " where " + wherefield + " = " + stringtool.sqlq(this[wherefield].tostring());
            return sql;
        }

        /// <summary>
        /// 转为sql 查询 语句
        /// </summary>
        /// <param name="tablename"></param>
        /// <returns></returns>
        public object[] towheresql()
        {
            object[] o = new object[2];
            string sql = @" where 1=1 ";
            dbparameter[] dbp = new dbparameter[list.count];
            int index = 0;
            foreach (keyvaluepair<string, object> f in list)
            {
                if (f.value is string)
                {
                    if (!f.key.contains("#"))
                    {
                        sql += " and " + f.key + " like '%'+@" + f.key + "+'%'";
                    }
                    else
                    {
                        string op = f.key.split('#')[1].tostring();
                        if (op.trim() == "l") //前半部相配
                        {
                            sql += " and " + f.key.split('#')[0] + " like '%'+@" + f.key + "";
                        }
                        else if (op.trim() == "r") //后半部相配
                        {
                            sql += " and " + f.key.split('#')[0] + " like  @" + f.key + "+'%'";
                        }
                        else if (op.trim() == "e")  //字符串相等
                        {
                            sql += " and " + f.key.split('#')[0] + " = @" + f.key;
                        }
                    }
                }
                if (f.value is int || f.value is decimal || f.value is double)
                {
                    if (!f.key.contains("#")) //无条件,直接带入
                    {
                        sql += " and " + f.key + " = @" + f.key;
                    }
                    else
                    {
                        string op = f.key.split('#')[1].tostring();
                        if (op.trim() == "g") //大于
                        {
                            sql += " and " + f.key.split('#')[0] + " > @" + f.key;
                        }
                        else if (op.trim() == "l") //小于
                        {
                            sql += " and " + f.key.split('#')[0] + " < @" + f.key;
                        }
                        else if (op.trim() == "ne") //不等于
                        {
                            sql += " and " + f.key.split('#')[0] + " <> @" + f.key;
                        }
                        else if (op.trim() == "ge") //大于等于
                        {
                            sql += " and " + f.key.split('#')[0] + " >= @" + f.key;
                        }
                        else if (op.trim() == "le") //小于等于
                        {
                            sql += " and " + f.key.split('#')[0] + " <= @" + f.key;
                        }
                        else if (op.trim() == "e")
                        {
                            sql += " or " + f.key.split('#')[0] + " = @" + f.key;
                        }
                    }
                }
                sqlparameter sp = new sqlparameter(f.key, f.value);
                dbp[index] = sp;
                index += 1;
            }
            o[0] = sql;
            o[1] = dbp;
            return o;
        }


    }
}