zoukankan      html  css  js  c++  java
  • 开发日记:JsonCSharpHelp

    using Newtonsoft.Json;
    using Newtonsoft.Json.Linq;
    using Newtonsoft.Json.Converters;
    

      

     public  static class JsonCSharpHelp
        {
            /// <summary>
            /// 取得某个Json value
            /// </summary>
            /// <param name="JsonString">{Name:aaaaa,Value:aaaa}</param>
            /// <param name="tagName"></param>
            /// <returns></returns>
            public static string GetJsonValue(string JsonString,string tagName)
            {
                JsonString = JsonString.TrimStart('{');
                JsonString = JsonString.TrimEnd('}');
                string[] splts = JsonString.Split(',');
                foreach (string tmp in splts)
                {
                    if (tmp != string.Empty)
                    {
                        string[] tag = tmp.Split(':');
                        if (tag[0] == tagName) return tag[1];                
                    }
                }
                return string.Empty;
            }
    
            /// <summary>
            /// 获取系统字典里的json对象集合
            /// json对象集合格式:[{"key":"1","value":"default"},{"key":"2","value":"default1"},{"key":"3","value":"default2"}]
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="JsonStr"></param>
            /// <returns></returns>
            public static List<T> JSONStringToList<T>(this string JsonStr)
            {
    
                /*JavaScriptSerializer Serializer = new JavaScriptSerializer();
    
                List<T> objs = Serializer.Deserialize<List<T>>(JsonStr);
    
                return objs;*/
    
    
                return JsonConvert.DeserializeObject<List<T>>(JsonStr);
            }
    
            /// <summary>
            /// 把json字符串转成对象
            /// </summary>
            /// <typeparam name="T">对象</typeparam>
            /// <param name="data">json字符串</param> 
            public static T JSONStringToObj<T>(string data)
            {
               /* JavaScriptSerializer json = new JavaScriptSerializer();
                return json.Deserialize<T>(data);*/
    
                return JsonConvert.DeserializeObject<T>(data);
            }
    
            /// <summary>
            /// 把对象转成json字符串
            /// </summary>
            /// <param name="o">对象</param>
            /// <returns>json字符串</returns>
            public static string ObjToJSONString(object o)
            {
                /*System.Text.StringBuilder sb = new System.Text.StringBuilder();
                JavaScriptSerializer json = new JavaScriptSerializer();
                json.Serialize(o, sb);
                return sb.ToString();*/
               // return JsonConvert.SerializeObject(o, new DataTableConverter());
                /*var jSetting = new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore };
                var json = JsonConvert.SerializeObject(response, Formatting.Indented, jSetting);*/
                return JsonConvert.SerializeObject(o, new JsonSerializerSettings() { DateFormatString = "yyyy-MM-dd hh:mm:ss"});
            }
    
            /// <summary>
            /// 将原表类型为decimal类型的数据改为string类型
            /// </summary>
            /// <param name="argDataTable"></param>
            /// <returns></returns>
            public static DataTable ModifyDataTableColumnType(DataTable argDataTable)
            {
                bool bl = false;
                DataTable dtResult = new DataTable();
                //克隆表结构
                dtResult = argDataTable.Clone();
                foreach (DataColumn col in dtResult.Columns)
                {
                    if (col.DataType == typeof(decimal))
                    {
                        //修改列类型
                        col.DataType = typeof(String);
                        bl = true;
                    }
                }
                if (bl)
                {
                    foreach (DataRow row in argDataTable.Rows)
                    {
                        DataRow rowNew = dtResult.NewRow();
                        rowNew.ItemArray = row.ItemArray;
                        dtResult.Rows.Add(rowNew);
                    }
                    return dtResult;
                }
                return argDataTable;
            } 
    
    
    
            /// <summary>
            /// 传入jsong串,获取匹配key的value值
            /// </summary>
            /// <param name="JsonStr"></param>
            /// <param name="matchKey"></param>
            /// <returns></returns>
            public static string GetSysParamValueByKey(string JsonStr, string matchKey)
            {
                string strResult = "";
                IList<SysParamJsonObj> list = JsonCSharpHelp.JSONStringToList<SysParamJsonObj>(JsonStr);
                foreach (SysParamJsonObj sysOjb in list)
                {
                    if (sysOjb.key.ToUpper() == matchKey.ToUpper())
                    {
                        strResult = sysOjb.value;
                        break;
                    }
                }
                return strResult;
            }
    
            /// <summary>
            ///根据对象SysParamJsonObj列表获取到某个key对应的value值
            /// </summary>
            /// <param name="list"></param>
            /// <param name="matchKey"></param>
            /// <returns></returns>
            public static string GetSysParamValueByKey(IList<SimpleParamObj> list, string matchKey)
            {
                string strResult = "";
                if (list == null) return strResult;
                foreach (SimpleParamObj sysOjb in list)
                {
                    if (sysOjb.K.ToUpper() == matchKey.ToUpper())
                    {
                        strResult = sysOjb.V;
                        break;
                    }
                }
                return strResult;
            }
    
            /// <summary>
            /// 获取一个类指定的属性值
            /// </summary>
            /// <param name="info">json对象 "{"3":123,body:456,list:{title:'abc',body:'what'}}"</param>
            /// <param name="field">属性名称</param>
            /// <param name="erro">输出错误信息</param>
            /// <returns></returns>
            public static object GetPropertyValue(object info, string field, out string erro)
            {
                erro = string.Empty;
                if (info == null) return null;
                JObject jo = null;
                try
                {
                    jo = JObject.Parse(info.ToString());
                }
                catch (Exception e)
                {
                    erro = "传入对象非json对象格式:" + e.Message;
                    return null;
                }
    
                if (jo.Property(field) == null || jo.Property(field).ToString() == "")            
                {
                    erro = "键值 " + field + " 不存在!";
                    return null;         
                }
                return jo.Property(field).Value;
            }
    
            /// <summary>
            /// 获取一个类指定的属性值
            /// </summary>
            /// <param name="info">json对象 "{"3":123,body:456,list:{title:'abc',body:'what'}}"</param>
            /// <param name="field">属性名称</param>
            /// <param name="erro">输出错误信息</param>
            /// <returns></returns>
            public static Hashtable GetPropertyValue(object info, string[] fields)
            {
                Hashtable ht = new Hashtable();
              //  erro = string.Empty;
                if (info == null) return null;
              //  Type t = info.GetType();
    
                // info = "{"3":123,body:456,list:{title:'abc',body:'what'}}";           
               /* if (t != typeof(JObject))
                {
                    erro = "传入对象非json对象格式";
                    return null;
                }*/
                JObject jo = null;
                try
                {
                    jo = JObject.Parse(info.ToString());
                }
                catch (Exception e)
                {
                   // erro = "传入对象非json对象格式:" + e.Message;
                    return null;
                }
                int len = fields.Length;
                object[] os = new object[len];
                IEnumerable<JProperty> properties = jo.Properties();
                int i = 0;
                bool bl = false;
                string f = string.Empty;
                for (i = 0; i < len; i++)
                {
                    bl = false; 
                    f = fields[i];
                    foreach (JProperty item in properties)
                    {
                        if (item.Name.ToUpper() == f.ToUpper())
                        {
                            ht.Add(f, item.Value);
                            //os[i] = item.Value;
                            bl = true;
                            break;
                        }
                    }
                    if (!bl)
                    {
                        ht.Add(f, "");
                      //  erro = "没有找到键值对匹配项" + f;
                       // return null;
                    }
                }
    
                return ht;
            }
    
    
            /// <summary>   
            /// 将Json序列化的时间由/Date(1294499956278+0800)转为字符串   
            /// </summary>   
            private static string ConvertJsonDateToDateString(Match m)
            {
                string result = string.Empty;
                DateTime dt = new DateTime(1970, 1, 1);
                dt = dt.AddMilliseconds(long.Parse(m.Groups[1].Value));
                dt = dt.ToLocalTime();
                result = dt.ToString("yyyy-MM-dd HH:mm:ss");
                return result;
            }
    
    
            /// <summary>    
            /// 将时间字符串转为Json时间   
            /// </summary>   
            private static string ConvertDateStringToJsonDate(Match m)
            {
                string result = string.Empty;
                DateTime dt = DateTime.Parse(m.Groups[0].Value);
                dt = dt.ToUniversalTime();
                TimeSpan ts = dt - DateTime.Parse("1970-01-01");
                result = string.Format("\/Date({0}+0800)\/", ts.TotalMilliseconds);
                return result;
            }
    
    
         /*   /// <summary>
            /// JSON序列化
            /// </summary>
            /// <param name="p"></param>
            /// <returns></returns>
            public static string JsonSerializer<T>(T t)
            {
                DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T));
                MemoryStream ms = new MemoryStream();
                ser.WriteObject(ms, t);
                string jsonString = Encoding.UTF8.GetString(ms.ToArray());
                ms.Close();
                string pattern = @"\/Date((d+)+d+)\/";
                MatchEvaluator matchEvaluator = new MatchEvaluator(ConvertJsonDateToDateString);
                Regex reg = new Regex(pattern);
                jsonString = reg.Replace(jsonString, matchEvaluator);
                return jsonString;
            }
            /// <summary>
            /// JSON反序列化
            /// </summary>
            /// <param name="jsonString"></param>
            /// <returns></returns>
            public static T JsonDeserialize<T>(string jsonString)
            {
                string pattern = @"d{4}-d{2}-d{2}sd{2}:d{2}:d{2}";
                MatchEvaluator matchEvaluator = new MatchEvaluator(ConvertDateStringToJsonDate);
                Regex reg = new Regex(pattern);
                jsonString = reg.Replace(jsonString, matchEvaluator);
                DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Person));
                MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));
                T obj = (T)ser.ReadObject(ms);
                return obj;
            }
            */
    
            /// <summary>   
            /// Datatable转换为Json   
            /// </summary>   
            /// <param name="table">Datatable对象</param>   
            /// <returns>Json字符串</returns>   
            public static string ToJson(DataTable dt)
            {
                StringBuilder jsonString = new StringBuilder();
                jsonString.Append("[");
                DataRowCollection drc = dt.Rows;
                for (int i = 0; i < drc.Count; i++)
                {
                    jsonString.Append("{");
                    for (int j = 0; j < dt.Columns.Count; j++)
                    {
                        string strKey = dt.Columns[j].ColumnName;
                        string strValue = drc[i][j].ToString();
                        Type type = dt.Columns[j].DataType;
                        jsonString.Append(""" + strKey + "":");
                        strValue = StringFormat(strValue, type);
                        if (j < dt.Columns.Count - 1)
                        {
                            jsonString.Append(strValue + ",");
                        }
                        else
                        {
                            jsonString.Append(strValue);
                        }
                    }
                    jsonString.Append("},");
                }
                jsonString.Remove(jsonString.Length - 1, 1);
                jsonString.Append("]");
                if (jsonString.Length == 1)
                {
                    return "[]";
                }
                return jsonString.ToString();
            }
    
            /// <summary>   
            /// Datatable转换为Json   
            /// </summary>   
            /// <param name="table">Datatable对象</param>   
            /// <param name="dataCount">数据总量 分页用</param>   
            /// <returns>Json字符串</returns>   
            public static string ToJson(DataTable dt, int dataCount)
            {
                StringBuilder jsonString = new StringBuilder();
                jsonString.Append("[");
                DataRowCollection drc = dt.Rows;
                for (int i = 0; i < drc.Count; i++)
                {
                    jsonString.Append("{");
                    jsonString.Append(""DATA_COUNT":" + dataCount + ",");
                    for (int j = 0; j < dt.Columns.Count; j++)
                    {
                        string strKey = dt.Columns[j].ColumnName;
                        string strValue = drc[i][j].ToString();
                        Type type = dt.Columns[j].DataType;
                        jsonString.Append(""" + strKey + "":");
                        strValue = StringFormat(strValue, type);
                        if (j < dt.Columns.Count - 1)
                        {
                            jsonString.Append(strValue + ",");
                        }
                        else
                        {
                            jsonString.Append(strValue);
                        }
                    }
                    jsonString.Append("},");
                }
                jsonString.Remove(jsonString.Length - 1, 1);
                jsonString.Append("]");
                if (jsonString.Length == 1)
                {
                    return "[]";
                }
                return jsonString.ToString();
            }
    
    
            /// <summary>  
            /// DataTable转成Json   
            /// </summary>  
            /// <param name="jsonName"></param>  
            /// <param name="dt"></param>  
            /// <returns></returns>  
            public static string ToJson(DataTable dt, string jsonName)
            {
                StringBuilder Json = new StringBuilder();
                if (string.IsNullOrEmpty(jsonName))
                    jsonName = dt.TableName;
                Json.Append("{"" + jsonName + "":[");
                if (dt.Rows.Count > 0)
                {
                    for (int i = 0; i < dt.Rows.Count; i++)
                    {
                        Json.Append("{");
                        for (int j = 0; j < dt.Columns.Count; j++)
                        {
                            Type type = dt.Rows[i][j].GetType();
                            Json.Append(""" + dt.Columns[j].ColumnName.ToString() + "":" + StringFormat(dt.Rows[i][j] is DBNull ? string.Empty : dt.Rows[i][j].ToString(), type));
                            if (j < dt.Columns.Count - 1)
                            {
                                Json.Append(",");
                            }
                        }
                        Json.Append("}");
                        if (i < dt.Rows.Count - 1)
                        {
                            Json.Append(",");
                        }
                    }
                }
                Json.Append("]}");
                return Json.ToString();
            }
    
            /// <summary>   
            /// DataReader转换为Json   
            /// </summary>   
            /// <param name="dataReader">DataReader对象</param>   
            /// <returns>Json字符串</returns>   
            public static string ToJson(IDataReader dataReader)
            {
                try
                {
                    StringBuilder jsonString = new StringBuilder();
                    jsonString.Append("[");
                    while (dataReader.Read())
                    {
                        jsonString.Append("{");
                        for (int i = 0; i < dataReader.FieldCount; i++)
                        {
                            Type type = dataReader.GetFieldType(i);
                            string strKey = dataReader.GetName(i);
                            string strValue = dataReader[i].ToString();
                            jsonString.Append(""" + strKey + "":");
                            strValue = StringFormat(strValue, type);
                            if (i < dataReader.FieldCount - 1)
                            {
                                jsonString.Append(strValue + ",");
                            }
                            else
                            {
                                jsonString.Append(strValue);
                            }
                        }
                        jsonString.Append("},");
                    }
                    if (!dataReader.IsClosed)
                    {
                        dataReader.Close();
                    }
                    jsonString.Remove(jsonString.Length - 1, 1);
                    jsonString.Append("]");
                    if (jsonString.Length == 1)
                    {
                        return "[]";
                    }
                    return jsonString.ToString();
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
    
            /// <summary>   
            /// DataSet转换为Json   
            /// </summary>   
            /// <param name="dataSet">DataSet对象</param>   
            /// <returns>Json字符串</returns>   
            public static string ToJson(DataSet dataSet)
            {
                string jsonString = "{";
                foreach (DataTable table in dataSet.Tables)
                {
                    jsonString += """ + table.TableName + "":" + ToJson(table) + ",";
                }
                jsonString = jsonString.TrimEnd(',');
                return jsonString + "}";
            }
    
            /// <summary>  
            /// 过滤特殊字符  
            /// </summary>  
            /// <param name="s"></param>  
            /// <returns></returns>  
            public static string String2Json(String s)
            {
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < s.Length; i++)
                {
                    char c = s.ToCharArray()[i];
                    switch (c)
                    {
                        case '"':
                            sb.Append("\""); break;
                        case '\':
                            sb.Append("\\"); break;
                        case '/':
                            sb.Append("\/"); break;
                        case '':
                            sb.Append("\b"); break;
                        case 'f':
                            sb.Append("\f"); break;
                        case '
    ':
                            sb.Append("\n"); break;
                        case '
    ':
                            sb.Append("\r"); break;
                        case '	':
                            sb.Append("\t"); break;
                        case 'v':
                            sb.Append("\v"); break;
                        case '':
                            sb.Append("\0"); break;
                        default:
                            sb.Append(c); break;
                    }
                }
                return sb.ToString();
            }
    
    
    
            /// <summary>  
            /// 格式化字符型、日期型、布尔型  
            /// </summary>  
            /// <param name="str"></param>  
            /// <param name="type"></param>  
            /// <returns></returns>  
            private static string StringFormat(string str, Type type)
            {
                if (type != typeof(string) && string.IsNullOrEmpty(str))
                {
                    str = """ + str + """;
                }
                else if (type == typeof(string))
                {
                    str = String2Json(str);
                    str = """ + str + """;
                }
                else if (type == typeof(DateTime))
                {
                    str = """ + str + """;
                }
                else if (type == typeof(bool))
                {
                    str = str.ToLower();
                }
                else if (type == typeof(byte[]))
                {
                    str = """ + str + """;
                }
                else if (type == typeof(Guid))
                {
                    str = """ + str + """;
                }
                return str;
            }
    
    
        }
    

      

        /// <summary>
        /// json对象
        /// </summary>
        [Serializable]
        public class SysParamJsonObj
        {
            /// <summary>
            /// id
            /// </summary>
            public string key;
    
            /// <summary>
            /// value
            /// </summary>
            public string value;
        }
    

      

  • 相关阅读:
    一行代码更改博客园皮肤
    fatal: refusing to merge unrelated histories
    使用 netcat 传输大文件
    linux 命令后台运行
    .net core 使用 Nlog 配置文件
    .net core 使用 Nlog 集成 exceptionless 配置文件
    Mysql不同字符串格式的连表查询
    Mongodb between 时间范围
    VS Code 使用 Debugger for Chrome 调试vue
    css权重说明
  • 原文地址:https://www.cnblogs.com/luomingui/p/9973131.html
Copyright © 2011-2022 走看看