JSON帮助类

最新推荐文章于 2022-10-26 10:55:30 发布
最新推荐文章于 2022-10-26 10:55:30 发布
阅读量138 收藏
点赞数
分类专栏： C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42046318/article/details/82697079
版权 
using System;
using System.Collections;
using System.Collections.Generic;
using System.Web;
using System.Web.Script.Serialization;
using System.Data;
using System.Text;
using System.ServiceModel;
using System.Runtime.Serialization.Json;
using System.IO;
using System.Reflection;

/// <summary>
    /// JSON帮助类
    /// </summary>
public class JSONHelper
{

    


    /// <summary>
    /// 对象转JSON
    /// </summary>
    /// <param name="obj">对象</param>
    /// <returns>JSON格式的字符串</returns>
    public static string ObjectToJSON(object obj)
    {
        JavaScriptSerializer jss = new JavaScriptSerializer();
        jss.MaxJsonLength = Int32.MaxValue;
        try
        {
            return jss.Serialize(obj);
        }
        catch (Exception ex)
        {

            throw new Exception("JSONHelper.ObjectToJSON(): " + ex.Message);
        }
    }
    /// <summary>
    /// 
    /// 同時將時間轉為 yyyy-MM-dd HH:mm:ss 格式
    /// </summary>
    /// <param name="obj"></param>
    /// <returns></returns>
    public static string ObjectToJSONConvertDate(object obj)
    {
        JavaScriptSerializer jss = new JavaScriptSerializer();
        try
        {
            string json = jss.Serialize(obj);
            string p = @"\\/Date\((-*\d+)\)\\/";
            System.Text.RegularExpressions.MatchEvaluator matchEvaluator = new System.Text.RegularExpressions.MatchEvaluator(ConvertJsonDateToDateString2);
            System.Text.RegularExpressions.Regex reg = new System.Text.RegularExpressions.Regex(p);
            json = reg.Replace(json, matchEvaluator);
            return json;
        }
        catch (Exception ex)
        {

            throw ex;
        }
    }
    /// <summary>
    /// 
    /// 同時將時間轉為 yyyy-MM-dd 格式
    /// </summary>
    /// <param name="obj"></param>
    /// <returns></returns>
    public static string ObjectToJSONDate(object obj)
    {
        JavaScriptSerializer jss = new JavaScriptSerializer();
        try
        {
            string json = jss.Serialize(obj);
            string p = @"\\/Date\((-*\d+)\)\\/";
            System.Text.RegularExpressions.MatchEvaluator matchEvaluator = new System.Text.RegularExpressions.MatchEvaluator(ConvertJsonDateToDate);
            System.Text.RegularExpressions.Regex reg = new System.Text.RegularExpressions.Regex(p);
            json = reg.Replace(json, matchEvaluator);
            return json;
        }
        catch (Exception ex)
        {

            throw ex;
        }
    }
    private static string ConvertJsonDateToDate(System.Text.RegularExpressions.Match m)
    {
        string result = string.Empty;
        DateTime dt = new DateTime(1970, 1, 1);
        dt = dt.AddMilliseconds(long.Parse(m.Groups[0].Value.ToString().Replace("\\/Date(", "").Replace(")\\/", "")));
        dt = dt.ToLocalTime();
        result = dt.ToString("yyyy-MM-dd");
        return result;
    }

    /// <summary>
    /// 数据表转键值对集合
    /// 把DataTable转成 List集合, 存每一行
    /// 集合中放的是键值对字典,存每一列
    /// </summary>
    /// <param name="dt">数据表</param>
    /// <returns>哈希表数组</returns>
    public static List<Dictionary<string, object>> DataTableToList(DataTable dt)
    {
        List<Dictionary<string, object>> list
             = new List<Dictionary<string, object>>();

        foreach (DataRow dr in dt.Rows)
        {
            Dictionary<string, object> dic = new Dictionary<string, object>();
            foreach (DataColumn dc in dt.Columns)
            {
                dic.Add(dc.ColumnName, dr[dc.ColumnName]);
            }
            list.Add(dic);
        }
        return list;
    }

    /// <summary>
    /// 数据集转键值对数组字典
    /// </summary>
    /// <param name="dataSet">数据集</param>
    /// <returns>键值对数组字典</returns>
    public static Dictionary<string, List<Dictionary<string, object>>> DataSetToDic(DataSet ds)
    {
        Dictionary<string, List<Dictionary<string, object>>> result = new Dictionary<string, List<Dictionary<string, object>>>();

        foreach (DataTable dt in ds.Tables)
            result.Add(dt.TableName, DataTableToList(dt));

        return result;
    }

    /// <summary>
    /// 数据表转JSON
    /// </summary>
    /// <param name="dataTable">数据表</param>
    /// <returns>JSON字符串</returns>
    public static string DataTableToJSON(DataTable dt)
    {
        return ObjectToJSON(DataTableToList(dt));
    }
     /// <summary>
    /// 数据表转JSON;同時將時間轉為 yyyy-MM-dd HH:mm:ss 格式
    /// </summary>
    /// <param name="dataTable">数据表</param>
    /// <returns>JSON字符串</returns>
    public static string DataTableToJSONConvertDate(DataTable dt)
    {
        return ObjectToJSONConvertDate(DataTableToList(dt));
    }
    /// <summary>
    /// 数据表转JSON;同時將時間轉為 yyyy-MM-dd 格式
    /// </summary>
    /// <param name="dataTable">数据表</param>
    /// <returns>JSON字符串</returns>
    public static string DataTableToJSONDate(DataTable dt)
    {
        return ObjectToJSONDate(DataTableToList(dt));
    }
    /// <summary>
    /// JSON文本转对象,泛型方法
    /// </summary>
    /// <typeparam name="T">类型</typeparam>
    /// <param name="jsonText">JSON文本</param>
    /// <returns>指定类型的对象</returns>
    public static T JSONToObject<T>(string jsonText)
    {
        JavaScriptSerializer jss = new JavaScriptSerializer();
        try
        {
            jss.MaxJsonLength = 5097152; //
            return jss.Deserialize<T>(ConvertJsonDate(jsonText));
        }
        catch (Exception ex)
        {
            throw new Exception("JSONHelper.JSONToObject(): " + ex.Message);
        }
    } 

    /// <summary>
    /// 将JSON文本转换为数据表数据
    /// </summary>
    /// <param name="jsonText">JSON文本</param>
    /// <returns>数据表字典</returns>
    /// 
    public static Dictionary<string, List<Dictionary<string, object>>> TablesDataFromJSON(string jsonText)
    {
        return JSONToObject<Dictionary<string, List<Dictionary<string, object>>>>(jsonText);
    }

    /// <summary>
    /// 将JSON文本转换成数据行
    /// </summary>
    /// <param name="jsonText">JSON文本</param>
    /// <returns>数据行的字典</returns>
    public static Dictionary<string, object> DataRowFromJSON(string jsonText)
    {
        return JSONToObject<Dictionary<string, object>>(jsonText);
    }

    /// <summary> 
    /// DataTable转Json 
    /// </summary> 
    /// <param name="dtb"></param> 
    /// <returns></returns> 
    public static string Dtb2Json(DataTable dtb)
    {
        JavaScriptSerializer jss = new JavaScriptSerializer();
        ArrayList dic = new ArrayList();
        foreach (DataRow row in dtb.Rows)
        {
            Dictionary<string, object> drow = new Dictionary<string, object>();
            foreach (DataColumn col in dtb.Columns)
            {
                drow.Add(col.ColumnName, row[col.ColumnName]);
            }
            dic.Add(drow);
        }
        return jss.Serialize(dic);
    }

    /// <summary> 
    /// DataTable转Json 
    /// </summary> 
    /// <param name="dtb"></param> 
    /// <param name="count"></param>   
    /// <returns></returns> 
    public static string Dtb2Json(DataTable dtb, int count)
    {
        if (dtb == null || dtb.Rows.Count == 0)
            return "{\"total\":0}";
        else
        {
            string json = Dtb2Json(dtb);
            if (json.Trim().Length > 0)
            {
                json = "{\"total\":" + count.ToString() + ",\"rows\":[" + json.Substring(1) + "}";
            }
            return json;
        }
    }

    /// <summary> 
    /// Json转DataTable 
    /// </summary> 
    /// <param name="json"></param> 
    /// <returns></returns> 
    public static DataTable Json2Dtb(string json)
    {
        JavaScriptSerializer jss = new JavaScriptSerializer();
        ArrayList dic = jss.Deserialize<ArrayList>(json);
        DataTable dtb = new DataTable();
        if (dic.Count > 0)
        {
            foreach (Dictionary<string, object> drow in dic)
            {
                if (dtb.Columns.Count == 0)
                {
                    foreach (string key in drow.Keys)
                    {
                        if (drow[key] == null)
                        {
                            Type tempT = null;
                            foreach (Dictionary<string, object> drow2 in dic)
                            {

                                foreach (string key2 in drow2.Keys)
                                {
                                    if (drow2[key2] != null && key2 == key)
                                    {
                                        tempT = drow2[key2].GetType();
                                        break;
                                    }
                                }
                                if (tempT != null)
                                    break;
                            }
                            if (tempT != null)
                                dtb.Columns.Add(key, tempT);
                            else
                                dtb.Columns.Add(key, System.Type.Missing.GetType());
                        }
                        else
                        {
                            //更正当第一行数据为int，后面数据为小数时取整
                            if (drow[key].GetType() == typeof(int))
                                dtb.Columns.Add(key, typeof(decimal));
                            else
                                dtb.Columns.Add(key, drow[key].GetType());
                        }
                    }
                }
                DataRow row = dtb.NewRow();
                foreach (string key in drow.Keys)
                {
                    row[key] = drow[key];
                }
                dtb.Rows.Add(row);
            }
        }
        return dtb;
    }

    /// <summary>   
    /// List转成json    
    /// </summary>   
    /// <typeparam name="T"></typeparam>   
    /// <param name="jsonName"></param>   
    /// <param name="list"></param>   
    /// <param name="count"></param>   
    /// <returns></returns>
    public static string ListToJson<T>(IList<T> list, string jsonName, int count)
    {
        if (list == null || list.Count == 0)
            return "{\"total\":0}";

        string json = ListToJson<T>(list, jsonName);
        if (json.Trim().Length > 0)
        {
            json = "{ \"total\":" + count.ToString() + "," + json.Substring(1);
        }
        json.Replace("\r\n", "");
        return json;
    }
    /// <summary>
    /// List转成json 
    /// 同時將時間轉為 yyyy-MM-dd HH:mm:ss 格式
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="list"></param>
    /// <param name="jsonName"></param>
    /// <param name="count"></param>
    /// <returns></returns>
    public static string ListToJsonAndConvertDate<T>(IList<T> list, string jsonName, int count)
    {
        if (list == null || list.Count == 0)
            return "{\"total\":0,\"" + jsonName + "\":[]}";//增加jsonName:[] 没有jsonName填充的datagrid appenRow会出错

        string json = ListToJson<T>(list, jsonName);
        if (json.Trim().Length > 0)
        {
            json = "{ \"total\":" + count.ToString() + "," + json.Substring(1);
        }
        string p = @"\\/Date\((-*\d+)\)\\/";
        System.Text.RegularExpressions.MatchEvaluator matchEvaluator = new System.Text.RegularExpressions.MatchEvaluator(ConvertJsonDateToDateString2);
        System.Text.RegularExpressions.Regex reg = new System.Text.RegularExpressions.Regex(p);
        json = reg.Replace(json, matchEvaluator);
        json.Replace("\r\n", "");
        return json;
    }
  
    private static string ConvertJsonDateToDateString2(System.Text.RegularExpressions.Match m)
    {
        string result = string.Empty;
        DateTime dt = new DateTime(1970, 1, 1);
        dt = dt.AddMilliseconds(long.Parse(m.Groups[0].Value.ToString().Replace("\\/Date(", "").Replace(")\\/", "")));
        dt = dt.ToLocalTime();
        result = dt.ToString("yyyy-MM-dd HH:mm:ss");
        return result;
    }
 
    /// <summary>   
    /// List转成json    
    /// </summary>   
    /// <typeparam name="T"></typeparam>   
    /// <param name="jsonName"></param>   
    /// <param name="list"></param>   
    /// <returns></returns>
    public static string ListToJson<T>(IList<T> list, string jsonName)
    {
        if (list == null || list.Count == 0)
            return "{}";

        StringBuilder Json = new StringBuilder();
        if (jsonName == "")
            Json.Append("[");
        else if (string.IsNullOrEmpty(jsonName))
            jsonName = "{\"" + list[0].GetType().Name + "\":[";
        else
            Json.Append("{\"" + jsonName + "\":[");
        if (list.Count > 0)
        {
            for (int i = 0; i < list.Count; i++)
            {               
                Json.Append(JSONHelper.ObjectToJSON(list[i]));
                if (i < list.Count - 1)
                {
                    Json.AppendLine(",");
                }
            }
        }
        Json.Append("]");
        if (jsonName != "")
            Json.Append("}");
        Json.Replace("\r\n", "");
        return Json.ToString();
    }

    /// <summary>   
    /// List转成json    
    /// </summary>   
    /// <typeparam name="T"></typeparam>   
    /// <param name="list"></param>   
    /// <returns></returns>   
    public static string ListToJson<T>(IList<T> list)
    {
        if (list == null || list.Count == 0)
            return "{}";

        object obj = list[0];
        return ListToJson<T>(list, obj.GetType().Name);
    }

    /// <summary>   
    /// List转成json 并带有没资料提示    WILSON
    /// </summary>   
    /// <typeparam name="T"></typeparam>   
    /// <param name="list"></param>   
    /// <returns></returns>   
    public static string ListToJsonByWilson<T>(IList<T> list, string jsonName)
    {
        string json = "";
        if (list.Count > 0)
        {
            json = JSONHelper.ListToJson<T>(list, jsonName);
            json = "[" + json.Insert(1, "\"status\":\"1\",") + "]";
        }
        else
            json = "[{\"status\":\"-1\",\"msg\":\"沒有符合條件的數據\"}]";
        json.Replace("\r\n", "");
        return json;
    }

    public static string ListToJsonByWilsonTrad<T>(IList<T> list, string jsonName)
    {
        string json = "";
        if (list.Count > 0)
        {
            json = JSONHelper.ListToJson<T>(list, jsonName);
            json = "[" + json.Insert(1, "\"status\":\"1\",") + "]";
        }
        else
            json = "[{\"status\":\"-1\",\"msg\":\"沒有符合條件的數據\"}]";
        json.Replace("\r\n", "");
        return Wilson.util.GeneralLib.SimplifiedToTraditional(json);
    }

    public static string ObjToJsonByWilson(object obj)
    {
        if (obj == null)
            return "";

        string json = "";
        json = JSONHelper.ObjectToJSON(obj);
        json = "[" + json.Insert(1, "\"status\":\"1\",") + "]";

        if (json.EndsWith(","))
            json = json.Substring(0, json.Length - 1);
        //json = json.Replace("[]", "");

        return json;
    }

    public static string ConvertJsonDate(string Json)
    {
        string p = @"/Date\(\-?\d+\)/";
        System.Text.RegularExpressions.MatchEvaluator matchEvaluator = new System.Text.RegularExpressions.MatchEvaluator(ConvertJsonDateToDateString);
        System.Text.RegularExpressions.Regex reg = new System.Text.RegularExpressions.Regex(p);
        return reg.Replace(Json, matchEvaluator);       
      
    }
    private static string ConvertJsonDateToDateString(System.Text.RegularExpressions.Match m)
    {
        string result = string.Empty;
        DateTime dt = new DateTime(1970, 1, 1);
        dt = dt.AddMilliseconds(long.Parse(m.Groups[0].Value.ToString().Replace("/Date(", "").Replace(")/", "")));
        dt = dt.ToLocalTime();
        result = dt.ToString("yyyy-MM-dd HH:mm:ss");
        return result;
    }
    public static string ConvertJsonDate2(string Json)
    {
        string p = @"\\/Date\(\-?\d+\)\\/";
        System.Text.RegularExpressions.MatchEvaluator matchEvaluator = new System.Text.RegularExpressions.MatchEvaluator(ConvertJsonDateToDateString2);
        System.Text.RegularExpressions.Regex reg = new System.Text.RegularExpressions.Regex(p);
        return reg.Replace(Json, matchEvaluator);

    }
    public static string GetJsonEnum(Type enumType)
    {
        return GetJsonEnum(enumType, null);
    }

    public static string GetJsonEnum(Type enumType, string alias)
    {
        int[] values = (int[])Enum.GetValues(enumType);
        string[] names = Enum.GetNames(enumType);
        string[] pairs = new string[values.Length];

        for (int i = 0; i < values.Length; i++)
        {
            pairs[i] = names[i] + ": " + values[i];
        }

        if (string.IsNullOrEmpty(alias))
            alias = enumType.Name;

        return string.Format("var {0}={{\n{1}\n}}", alias, string.Join(",\n", pairs));
    }

    public static string string2Json(string s)
    {
        string newstr = "";
        int len = s.Length;
        for (int i = 0; i < len; i++)
        {
            char[] c = s.ToCharArray();
            switch (c[i])
            {
                case '\"':
                    {
                        newstr += "\\\"";
                        break;
                    }
                case '\\':
                    {
                        newstr += "\\\\";
                        break;
                    }
                case '/':
                    {
                        newstr += "\\/";
                        break;
                    }
                case '\b':
                    {
                        newstr += "\\b";
                        break;
                    }
                case '\f':
                    {
                        newstr += "\\f";
                        break;
                    }
                case '\n':
                    {
                        newstr += "\\n";
                        break;
                    }
                case '\r':
                    {
                        newstr += "\\r";
                        break;
                    }
                case '\t':
                    {
                        newstr += "\\t";
                        break;
                    }
                default:
                    {
                        newstr += c[i].ToString();
                        break;
                    }
            }
        }
        return newstr;
    }

    /// <summary>
    /// 
    /// 同時將時間轉為 yyyy-MM-dd格式
    /// </summary>
    /// <param name="obj"></param>
    /// <returns></returns>
    public static string ObjectToJSONConvertDateShort(object obj)
    {
        JavaScriptSerializer jss = new JavaScriptSerializer();
        try
        {
            string json = jss.Serialize(obj);
            string p = @"\\/Date\((-*\d+)\)\\/";
            System.Text.RegularExpressions.MatchEvaluator matchEvaluator = new System.Text.RegularExpressions.MatchEvaluator(ConvertJsonDateToDateStringShort);
            System.Text.RegularExpressions.Regex reg = new System.Text.RegularExpressions.Regex(p);
            json = reg.Replace(json, matchEvaluator);
            return json;
        }
        catch (Exception ex)
        {

            throw ex;
        }
    }

    private static string ConvertJsonDateToDateStringShort(System.Text.RegularExpressions.Match m)
    {
        string result = string.Empty;
        DateTime dt = new DateTime(1970, 1, 1);
        dt = dt.AddMilliseconds(long.Parse(m.Groups[0].Value.ToString().Replace("\\/Date(", "").Replace(")\\/", "")));
        dt = dt.ToLocalTime();
        result = dt.ToString("yyyy-MM-dd");
        return result;
    }


    /// <summary>
    /// List转成json 
    /// 同時將時間轉為 yyyy-MM-dd HH:mm:ss 格式
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="list"></param>
    /// <param name="jsonName"></param>
    /// <param name="count"></param>
    /// <returns></returns>
    public static string ListToJsonAndConvertDateShort<T>(IList<T> list, string jsonName, int count)
    {
        if (list == null || list.Count == 0)
            return "{\"total\":0}";

        string json = ListToJson<T>(list, jsonName);
        if (json.Trim().Length > 0)
        {
            json = "{ \"total\":" + count.ToString() + "," + json.Substring(1);
        }

       //只获取正整数部分，不考虑大于1970年问题  
       //string p = @"\\/Date(\d+)\\/";  
      //考虑小于1970年的问题  
    
       string p = @"\\/Date\((-*\d+)\)\\/";
        System.Text.RegularExpressions.MatchEvaluator matchEvaluator = new System.Text.RegularExpressions.MatchEvaluator(ConvertJsonDateToDateString2Short);
        System.Text.RegularExpressions.Regex reg = new System.Text.RegularExpressions.Regex(p);
        json = reg.Replace(json, matchEvaluator);
        json.Replace("\r\n", "");
        return json;
    }

    private static string ConvertJsonDateToDateString2Short(System.Text.RegularExpressions.Match m)
    {
        string result = string.Empty;
        DateTime dt = new DateTime(1970, 1, 1);
        dt = dt.AddMilliseconds(long.Parse(m.Groups[1].Value)); 
        //dt = dt.AddMilliseconds(long.Parse(m.Groups[0].Value.ToString().Replace("\\/Date(", "").Replace(")\\/", "")));
        dt = dt.ToLocalTime();
        result = dt.ToString("yyyy-MM-dd");
        return result;
    }


}

 

SeanXiong2018
关注
专栏目录
.NET Json帮助类
11-11
本篇文章将深入探讨.NET中的Json帮助类，包括`System.Text.Json`和第三方库如`Newtonsoft.Json`，以及它们的主要功能和用法。 1. **System.Text.Json** 自从.NET Core 3.0引入以来，`System.Text.Json`已成为.NET...
net core json 转换帮助类 JsonHelper
软件开发实战经验
12-02 1093
net core json帮助类
C#工具类：Json操作帮助类（转载）
weixin_30520015的博客
03-25 139
原文转载自C#工具类：Json操作帮助类_IT技术小趣屋。 Json序列化和反序列化在程序开发中时常会遇到，在C#中可以使用很多种方法实现对数据的Json序列化和反序列化，封装一个Json操作工具类来简化相应的操作，该工具类中包含以下功能：对象转JSON、数据表转键值对集合、数据集转键值对数组字典 、数据表转JSON、JSON文本转对象(泛型方法)、将JSON文本转换为数据表数据、将JSON文本...
Json帮助类库
kevinshift的博客
01-12 451
（1） https://github.com/isair/JSONHelper （2） 比较全的，有四个类。https://www.cnblogs.com/yuangang/p/5468777.html
JsonHelper（Json帮助类）
weixin_34060299的博客
03-22 599
1 /// <summary> 2 /// Json帮助类 3 /// </summary> 4 public class JsonHelper 5 { 6 /// <summary> 7 /// 将对象序列化为JSON格式...
【C#公共帮助类】JsonHelper 操作帮助类， 以后再也不用满地找Json了，拿来直接用...
08-25 373
四个主要操作类：JsonConverter 、JsonHelper 、JsonSplit 、AjaxResult 一、JsonConverter： 自定义查询对象转换动态类、object动态类转换json包、json转换object动态类、DataReader转换为Json、DataSet转换为Json、DataTable转成Json、Datatable转换为Json...
json帮助类
01-29
`JsonUtils.java`可能是一个自定义的帮助类，它封装了`json-lib`和`Apache Commons BeanUtils`的部分功能，以供项目内部使用。这个类可能会包含一些静态方法，如`fromJsonToMap(String jsonString)`将JSON字符串转换...
Json帮助类.rar
05-15
这个"Json帮助类.rar"压缩包提供了相关的类库代码，帮助开发者进行这些操作。 首先，我们来看列表集合(List)转换为JSON。在.NET中，可以使用Newtonsoft.Json库的JsonConvert类的SerializeObject方法来实现。例如，...
C#的JavaScript和Json帮助类
最新发布
01-02
JavaScript（简称JS）是一种面向对象的脚本语言，主要用于在网页上实现交互和动态效果。它最初是为了在浏览器中操作网页元素而...JavaScript提供了内置的JSON对象，可以通过JSON对象的方法来解析和生成JSON格式的数据。
asp.net JSONHelper JSON帮助类
01-01
代码如下:/************************************************** * 版权所有: Mr_Sheng * 文 件 名: JSONHelper.cs * 文件描述: * 类型说明: JSONHelper JSON帮助类 * 授权声明: * 本程序为自由软件； * 您可依据...
JsonHelper帮助类
08-22
JsonHelper帮助类，提供常用的json字符串与datable，实体对象，字典之间的相互转化方法，项目开发过程中可直接使用，减少代码编写
JSONjs包json.js
12-07
json.js json.js json.js json.js json.js json.js json.js json.js json.js json.js json.js json.js json.js json.js json.js json.js json.js
JSON 帮助类
仙剑的专栏
09-25 1582
/// /// 用于构建属性值的回调 /// /// public delegate void SetProperties(JsonObject Property); /// /// JsonObject属性值类型 /// public enum JsonPropertyType { String,
datatable转换成json
weixin_30680385的博客
03-29 60
public static string Dtb2Json(DataTable dtb) { JavaScriptSerializer jss = new JavaScriptSerializer(); ArrayList dic = new ArrayList(); foreach (DataRo...
C#常用JSON数据操作类
BigBossc的博客
01-17 757
using Newtonsoft.Json; using System; using System.Collections.Generic; using System.Data; using System.IO; using System.Linq; using System.Reflection; using System.Web; using System.Web.Script.Serial...
C# 手把手教你写一个自己的Json文件读取帮助类
qq_43535970的博客
10-26 1885
在.net core或者高版本的.net框架中，很多基础函数的用法已经给你封装的很好了，比如我们就可以配置后直接使用Configuration[‘property’]来获取json文件的内容。但是在一些老项目当中，你可能就用不了那些封装好的库了，你会为了读取一些json文件、xml文件而焦头烂额。此时，我建议读一读这篇文章。json文件通常在我们的一个项目中，用作一些参数的配置文件。因为在项目打包运行中，json文件不会被编译而是保留下来。
Java重写Gson实现JSON操作工具类
这个方法在接收服务器响应或读取JSON文件后还原数据结构时很有帮助。 3. `fromJsonToCollection(String json, Type collectionType)`：将JSON字符串反序列化为Java集合，如List或Set。这个方法允许你处理包含多个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值