c# 常用json与实体互转方法，比较多，做了一个总结

最新推荐文章于 2024-06-05 21:35:15 发布
最新推荐文章于 2024-06-05 21:35:15 发布
阅读量1.9k 收藏 1
点赞数 1
文章标签： c# json java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fillg/article/details/132577621
版权 
  public static Dictionary<string, string> dictionary = new Dictionary<string, string>();
  public static List<Dictionary<string, string>> listDic = new List<Dictionary<string, string>>();
        
        /// <summary>
        /// Json字符串 Key首字母大写以对应实体
        /// </summary>
        /// <param name="text"></param>
        /// <param name="toUp">true 大写 false 小写</param>
        /// <param name="changeDate">true \\/Date(xxxxxx)\\/ 反序列化至实体用false                   
            xxxxxx序列化传出用 </param>
        /// <returns></returns>
        public static string ChangeSourceJonson(string text, bool toUp, bool changeDate)
        {

            Regex rg = new Regex("[\"]+[a-zA-z]+[0-9]*[\"]+[:]+");
            MatchCollection keys = rg.Matches(text, 0);
            string firstcharacter = null;
            string newkey = null;
            List<string> hasreplacedkeys = new List<string>();
            List<int> deleteIndex = new List<int>();
            List<int> deleteLength = new List<int>();
            List<string> newStringValue = new List<string>();
            for (int i = 0; i < keys.Count; i++)
            {
                if (keys[i].Value.ToLower().Contains("time") ||keys[i].Value.ToLower().EndsWith("birth"))
                {
                    for (int j = keys[i].Index + keys[i].Length; ; j++)
                    {
                        if (text.Substring(j, 1) == "," || text.Substring(j, 1) == "}")
                        {
                            string value = text.Substring(keys[i].Index + keys[i].Length, j - keys[i].Index - keys[i].Length);
                            string newvalue = null;
                            if (changeDate)
                            {
                                newvalue = value == "null" ? "\"\\/Date(" + "0" + ")\\/\"" : "\"\\/Date(" + value + ")\\/\"";
                            }
                            else if (!changeDate)
                            {
                                newvalue = value == "null" ? "0" : value;
                                if (value.StartsWith("\"") && value.EndsWith("\""))
                                {
                                    newvalue = value.Replace("\"", "");
                                    if (newvalue.Contains(" "))
                                    {
                                        newvalue = GetDateLong(newvalue).ToString();
                                    }
                                    else
                                    {
                                        newvalue = System.Convert.ToDateTime(newvalue).Ticks.ToString();
                                    }
                                }
                            }
                            deleteIndex.Add(keys[i].Index + keys[i].Length);
                            deleteLength.Add(value.Length);
                            newStringValue.Add(newvalue);
                            break;
                        }
                    }
                }
                if (!hasreplacedkeys.Contains(keys[i].Value))
                    hasreplacedkeys.Add(keys[i].Value);
                else continue;
                firstcharacter = keys[i].Value.Substring(1, 1);
                if (toUp)
                {
                    firstcharacter = firstcharacter.ToUpper();
                }
                if (!toUp)
                {
                    firstcharacter = firstcharacter.ToLower();
                }
                newkey = "\"" + firstcharacter + keys[i].Value.Substring(2);
                text = text.Replace(keys[i].Value, newkey);
            }

            for (int i = deleteLength.Count - 1; i >= 0; i--)
            {
                text = text.Remove(deleteIndex[i], deleteLength[i]);
                text = text.Insert(deleteIndex[i], newStringValue[i]);
            }
            text = text.Replace("\r", "\\r");
            text = text.Replace("\n", "\\n");

            return text;

        }

        /// <summary>
        /// Json字符串 Key首字母大写以对应实体
        /// </summary>
        /// <param name="JsonString"></param>
        /// <returns></returns>
        public static string ConvertJson(string JsonString)
        {
            listDic = new List<Dictionary<string, string>>();
            dictionary = new Dictionary<string, string>();
            bool IsList = false;
            string ss = "";
            StringBuilder Strb = new StringBuilder();
            if (JsonString.IndexOf('[') == 0)
            {
                IsList = true;
                JsonString = JsonString.Remove(0, 1);
                JsonString = JsonString.Remove(JsonString.Length - 1, 1);
                Strb.Append("[");
            }
            string Start1 = JsonString.Replace("\"", "");
            string[] start4 = Start1.Split('{');
            StringBuilder Str = new StringBuilder();
            for (int i = 0; i < start4.Length; i++)
            {
                dictionary = new Dictionary<string, string>();
                if (i != 0)
                {
                    Str.Append("{");
                    for (int index = 0; index < start4[i].Length; index++)
                    {
                        int tempKeyStartIndex = index;
                        int tempKeyEndIndex = start4[i].IndexOf(':');
                        string tempkey = start4[i].Substring(index, tempKeyEndIndex - tempKeyStartIndex);
                        index = tempKeyEndIndex;
                    }

                }

                string[] splits = start4[i].Split(',');
                for (int j = 0; j < splits.Length; j++)
                {
                    string SplitString = splits[j].Replace("]", "");
                    SplitString = splits[j].Replace("}", "");
                    SplitString.Trim();
                    if (SplitString != null && SplitString != string.Empty)
                    {
                        SplitString = SplitString.Substring(0, 1).ToUpper() + SplitString.Substring(1, SplitString.Length - 1);
                        string[] ThredSplit = SplitString.Split(':');
                        for (int index = 0; index < ThredSplit.Length; index++)
                        {
                            if (index == 0)
                            {
                                string Key = ThredSplit[index];
                                Str.Append('\"');
                                Str.Append(Key);
                                Str.Append('\"');
                                Str.Append(':');
                            }
                            if (index == 1)
                            {
                                string key = ThredSplit[index - 1];

                                string Value = ThredSplit[index];
                                if (key.Contains("Time") || key.Contains("time"))
                                {
                                    if (Value == "null")
                                    {
                                        Value = "0";
                                    }
                                    Value = @"/Date(" + Value + @")/";
                                }
                                Str.Append('\"');
                                Str.Append(Value);
                                Str.Append('\"');
                                Str.Append(',');
                                dictionary.Add(key, Value);
                            }
                        }
                    }
                }
                if (i != 0)
                {
                    Str.Append("}");
                    Str.Remove(Str.ToString().LastIndexOf(','), 1);
                    Str.Append(",");
                    if (IsList)
                    {
                        listDic.Add(dictionary);
                    }
                }
            }
            Str.Remove(Str.ToString().LastIndexOf(','), 1);
            Strb.Append(Str);
            if (IsList)
            {
                Strb.Append("]");//int count = 0;
            }
            return Strb.ToString();
        }

        /// <summary>
        /// Json转实体类型
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="JsonString"></param>
        /// <returns></returns>
        public static T JsonToModel<T>(string JsonString)
        {
            //JsonString = ChangeSourceJonson(JsonString);
            using (MemoryStream ms = new MemoryStream(Encoding.Unicode.GetBytes(JsonString)))
            {
                try
                {
                    DataContractJsonSerializer deseralizer = new DataContractJsonSerializer(typeof(T));
                    T returnOrg = (T)deseralizer.ReadObject(ms);
                    return returnOrg;
                }
                catch (Exception ex)
                {
                    throw ex;
                }
                finally
                {
                    ms.Close();
                    ms.Dispose();
                }
            }
        }

        /// <summary>
        /// Json反序列化批量转换实体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="JsonString"></param>
        /// <returns></returns>
        public static List<T> JsonToList<T>(string JsonString)
        {
            return JsonToModel<List<T>>(JsonString);
        }

        /// <summary>
        /// 序列化json
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public static string ModelToJson<T>(T t)
        {
            try
            {
                DataContractJsonSerializer js = new DataContractJsonSerializer(typeof(T));
                MemoryStream mobj = new MemoryStream();
                js.WriteObject(mobj, t);
                mobj.Position = 0;
                StreamReader sr = new StreamReader(mobj, Encoding.UTF8);
                string Json = sr.ReadToEnd();
                sr.Close();
                mobj.Close();
                return Json;
            }
            catch (Exception ex)
            {
                return null;
            }
        }

        /// <summary>
        /// 转化为JsonBody用作请求传参
        /// </summary>
        /// <param name="dic">key value</param>
        /// <returns></returns>
        public static string ConvertToBodyJson(Dictionary<string, string> dic)
        {
            StringBuilder BodyJson = new StringBuilder();
            if (dic.Count != 0)
            {
                BodyJson.Append('{');
            }
            foreach (var item in dic)
            {
                if (item.Value != "" && item.Value != null)
                {
                    BodyJson.Append("\"");
                    BodyJson.Append(item.Key);
                    BodyJson.Append("\"");
                    BodyJson.Append(":");
                    if (item.Value.Contains("[") && item.Value.Contains("]"))
                    {
                        BodyJson.Append(item.Value);
                    }
                    else
                    {
                        BodyJson.Append("\"");
                        BodyJson.Append(item.Value);
                        BodyJson.Append("\"");
                    }
                    BodyJson.Append(",");
                }
            }
            if (BodyJson.ToString().LastIndexOf(',') != -1)
            {
                // MessageBox.Show(BodyJson.ToString());
                BodyJson.Remove(BodyJson.ToString().LastIndexOf(','), 1);

            }
            if (dic.Count != 0)
            {
                BodyJson.Append("}");
            }
            return BodyJson.ToString();
        }

        public static List<Dictionary<string, object>> JsonToListDictionary(string json)
        {
            List<Dictionary<string, object>> listDictionary = new List<Dictionary<string, object>>();
            List<int> indexs = new List<int>();
            int index = 0;
            List<string> stringList = new List<string>();
            if (json.StartsWith("["))
            {
                for (int i = 0; i < json.Length; i++)
                {
                    index = json.IndexOf("{", index + 1);
                    if (index == -1) break;
                    indexs.Add(index);
                }
                indexs.Add(json.LastIndexOf("}"));
                for (int i = 0; i < indexs.Count - 1; i++)
                {
                    stringList.Add(json.Substring(indexs[i], indexs[i + 1] - indexs[i]));
                }
                for (int i = 0; i < stringList.Count; i++)
                {
                    listDictionary.Add(JsonToDictionary(stringList[i], false));
                }
                return listDictionary;
            }
            return null;
        }

        /// <summary>
        /// Json返回值转化为字典处理 对应keyvalues字典
        /// </summary>
        /// <param name="json"></param>
        public static Dictionary<string, object> JsonToDictionary(string json, bool isUp)
        {
            Dictionary<string, object> keyvalues = new Dictionary<string, object>();
            if (json.StartsWith("{"))
            {
                int index = 0;
                bool addkey = true;
                int count = 0;
                string key = null;
                for (int i = 0; i < json.Length; i++)
                {
                    index = json.IndexOf("\"", index);
                    if (index == -1) break;
                    count++;
                    if (count % 2 == 1)
                    {
                        int index2 = json.IndexOf("\"", index + 1);
                        key = json.Substring(index + 1, index2 - index - 1);
                        if (string.IsNullOrEmpty(key)) break;
                        if (isUp)
                            key = key.ToUpper().Substring(0, 1) + key.Substring(1);
                        int indexof2dots = json.IndexOf(":", index2);
                        if (indexof2dots == -1) break;
                        int indexofdot = json.IndexOf(",", indexof2dots);
                        int indexof2dots_1 = json.IndexOf(":", indexof2dots + 1);
                        if (indexof2dots_1 != -1)
                        {
                            int indexofdot_1 = json.IndexOf(",", indexofdot + 1);
                            if (indexofdot_1 > indexofdot && indexofdot_1 < indexof2dots_1)
                                indexofdot = indexofdot_1;
                        }
                        string tempvalue = "";
                        if (indexofdot != -1)
                        {
                            tempvalue = json.Substring(indexof2dots + 1, indexofdot - indexof2dots - 1);
                        }
                        else
                        {
                            tempvalue = json.Substring(indexof2dots + 1, json.Length - 1 - indexof2dots - 1);
                            if (tempvalue.Length == 0)
                            {
                                tempvalue = json.Substring(indexof2dots + 1, 1);
                            }
                            if (tempvalue.StartsWith("\"") && !tempvalue.EndsWith("\""))
                            {
                                tempvalue = tempvalue.Substring(1);
                            }

                        }
                        tempvalue = tempvalue.Replace("}", "");

                        if (!tempvalue.Contains("[") && tempvalue.StartsWith("\"") && tempvalue.EndsWith("\""))
                        {
                            tempvalue = tempvalue.Substring(1, tempvalue.Length - 2);
                        }
                        string value = "";
                        if (index2 + 2 + 4 < json.Length)
                            value = json.Substring(index2 + 2, 4);
                        if (value.Contains("}"))
                        {
                            int index3 = json.IndexOf("\"", index2 + 1);
                            keyvalues.Add(key, "");
                            keyvalues[key] = json.Substring(index3 + 1, index3 - index2 - 1);
                            break;
                        }
                        string value1 = "";
                        if (index2 + 2 + 5 < json.Length)
                            value = json.Substring(index2 + 2, 5);

                        bool isNumber = false;
                        try { System.Convert.ToInt32(value1); isNumber = true; } catch { isNumber = false; }
                        if (isNumber)
                        {
                            for (int j = index2 + 7; ; j++)
                            {
                                try { System.Convert.ToInt32(json.Substring(j, 1)); value1 += json.Substring(j, 1); }
                                catch
                                {
                                    keyvalues.Add(key, value1);
                                    addkey = true;
                                    break;
                                }
                            }
                        }
                        else if (value == "null")
                        {
                            keyvalues.Add(key, "null");
                            addkey = true;
                        }
                        else if (value == "true")
                        {
                            keyvalues.Add(key, "true");
                            addkey = true;
                        }
                        else if (value1 == "false")
                        {
                            keyvalues.Add(key, "false");
                            addkey = true;
                        }
                        else if (!tempvalue.Contains("["))
                        {
                            keyvalues.Add(key, tempvalue);
                            if (indexofdot != -1)
                                index2 = indexofdot;
                            addkey = true;
                        }
                        else
                        {
                            keyvalues.Add(key, "");
                            addkey = false;
                        }
                        index = index2 + 1;
                        i = index;
                        if (keyvalues[key].ToString().Length > 1000 && !keyvalues[key].ToString().Contains("-") && !keyvalues[key].ToString().Contains(","))
                        {
                            keyvalues[key] = System.Convert.FromBase64String(keyvalues[key].ToString());
                        }


                    }
                    else if (!addkey)
                    {
                        int index2 = json.IndexOf("\"", index + 1);
                        if (json.Substring(index - 1, 1) == "[")
                        {
                            index2 = json.IndexOf("]", index + 1);
                            index--;
                        }
                        keyvalues[key] = json.Substring(index + 1, index2 - index - 1);
                        if (keyvalues[key].ToString().Length > 32 && !keyvalues[key].ToString().Contains("-") && !keyvalues[key].ToString().Contains(","))
                        {
                            keyvalues[key] = System.Convert.FromBase64String(keyvalues[key].ToString());
                        }
                        index = index2 + 1;
                        i = index;
                        addkey = true;
                    }
                }
                return keyvalues;
            }
            return null;
        }

        /// <summary>
        /// Post请求结果
        /// </summary>
        /// <param name="Json">Body Json数据</param>
        /// <param name="Url">请求地址</param>
        /// <returns></returns>
        public static String PostResultJson(string Json, string Url)
        {
            try
            {
                string Result = "";
                String URl = Url;
                HttpWebRequest req = (HttpWebRequest)WebRequest.Create(URl);
                req.Method = "POST";
                req.ContentType = "application/json";
                //Console.WriteLine("b");
                using (var streamWriter = new StreamWriter(req.GetRequestStream()))
                {
                    //Console.WriteLine("c");
                    string json = Json;
                    streamWriter.Write(json);
                }
                var response = (HttpWebResponse)req.GetResponse();
                //Console.WriteLine("d");
                using (var streamReader = new StreamReader(response.GetResponseStream()))
                {
                    //Console.WriteLine("e");
                    Result = streamReader.ReadToEnd();
                }
                return Result;
            }
            catch (ProtocolViolationException ex)
            {
                Console.WriteLine(ex.Message + "\r\nProtocolViolationException\r\n" + ex.StackTrace);
            }
            catch (NotSupportedException ex)
            {
                Console.WriteLine(ex.Message + "\r\nNotSupportedException\r\n" + ex.StackTrace);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message + "\r\n" + ex.StackTrace);
            }
            return null;
        }
        private static bool RemoteCertificateValidate(object sender, X509Certificate cert, X509Chain chain, System.Net.Security.SslPolicyErrors error)
        {
            return true;
        }

        /// <summary>
        /// Get请求结果
        /// </summary>
        /// <param name="Url">请求地址</param>
        /// <returns></returns>

        public static String GetResultJson(string Url)

        {

            try
            {
                string result = "";
                HttpWebRequest req = (HttpWebRequest)WebRequest.Create(Url);
                req.Method = "GET";
                HttpWebResponse resp = (HttpWebResponse)req.GetResponse();
                Stream stream = resp.GetResponseStream();
                //获取内容
                using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))
                {
                    result = reader.ReadToEnd();
                }
                return result;
            }
            catch (Exception ex)
            {
                return null;
            }

        }

        /// <summary>
        /// Put请求结果
        /// </summary>
        /// <param name="Json">BodyJson</param>
        /// <param name="Url">请求地址</param>
        /// <returns></returns>
        public static String PutResultJson(string Json, string Url)
        {

            try
            {
                string Result = "";
                String URl = Url;
                HttpWebRequest req = (HttpWebRequest)WebRequest.Create(URl);
                req.Method = "PUT";
                req.ContentType = "application/json";
                if (Json != "" && Json != null)
                {
                    using (var streamWriter = new StreamWriter(req.GetRequestStream()))
                    {
                        string json = Json;
                        streamWriter.Write(json);
                    }
                }
                var response = (HttpWebResponse)req.GetResponse();
                using (var streamReader = new StreamReader(response.GetResponseStream()))
                {
                    Result = streamReader.ReadToEnd();
                }
                return Result;
            }
            catch (ProtocolViolationException ex)
            {
                Console.WriteLine(ex.Message + "\r\nProtocolViolationException\r\n" + ex.StackTrace);
            }
            catch (NotSupportedException ex)
            {
                Console.WriteLine(ex.Message + "\r\nNotSupportedException\r\n" + ex.StackTrace);
            }
            catch (Exception ex)
            {
            }
            return null;
        }

        /// <summary>
        /// Delete请求结果
        /// </summary>
        /// <param name="Url">请求地址</param>
        /// <returns></returns>
        public static String DeleteResultJson(string Url)
        {

            try
            {
                string result = "";
                HttpWebRequest req = (HttpWebRequest)WebRequest.Create(Url);
                req.Method = "DELETE";
                HttpWebResponse resp = (HttpWebResponse)req.GetResponse();
                Stream stream = resp.GetResponseStream();
                //获取内容
                using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))
                {
                    result = reader.ReadToEnd();
                }
                return result;
            }
            catch (Exception ex)
            {
                return null;
            }
        }

        /// <summary>
        /// Delete请求结果
        /// </summary>
        /// <param name="Url">请求地址</param>
        /// <returns></returns>
        public static String DeleteResultJson(string Json, string Url)
        {
            try
            {
                string Result = "";
                String URl = Url;
                HttpWebRequest req = (HttpWebRequest)WebRequest.Create(URl);
                req.Method = "DELETE";
                req.ContentType = "application/json";
                using (var streamWriter = new StreamWriter(req.GetRequestStream()))
                {
                    string json = Json;
                    streamWriter.Write(json);
                }
                var response = (HttpWebResponse)req.GetResponse();
                using (var streamReader = new StreamReader(response.GetResponseStream()))
                {
                    Result = streamReader.ReadToEnd();
                }
                return Result;
            }
            catch (Exception ex)
            {
                return null;
            }
        }

        /// <summary>
        /// DateTime  转化LongTick
        /// </summary>
        /// <param name="time"></param>
        /// <returns></returns>
        public static long GetDateLong(object time)
        {
            DateTime epoc = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1));
            TimeSpan delta = new TimeSpan();
            if (time is DateTime)
            {
                System.DateTime startTime = TimeZone.CurrentTimeZone.ToLocalTime(new System.DateTime(1970, 1, 1, 0, 0, 0, 0));
                long t = (((DateTime)time).Ticks - startTime.Ticks) / 10000;   //除10000调整为13位      
                return t;
            }
            else if (time is string)
            {
                delta = DateTime.Parse(time.ToString()).Subtract(epoc);
            }

            long ticks = (long)delta.TotalMilliseconds;
            if (ticks < 0)
            {
                return 0;
            }
            return ticks;
        }

        /// <summary>
        /// LongTicks 转datetime
        /// </summary>
        /// <param name="ticks"></param>
        /// <returns></returns>
        public static DateTime GetDateTimeFromLong(long ticks)
        {
            var date = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1));
            date = date.AddMilliseconds(ticks);
            return date;
        }

        public static Dictionary<string, object> JsonOfPage(string Json)
        {
            Dictionary<string, object> dictionary = new Dictionary<string, object>();
            int EntitiesIndex = Json.IndexOf("entities");
            int TotalIndex = Json.IndexOf("total");
            string total = Json.Substring(TotalIndex + 7, EntitiesIndex - TotalIndex - 7 - 2);
            string Entities = Json.Substring(EntitiesIndex + 10, Json.Length - 1 - EntitiesIndex - 10);
            dictionary.Add("total", total);
            dictionary.Add("list", Entities);
            return dictionary;
        }


        /// <summary>
        ///  AES 加密
        /// </summary>
        /// <param name="str">明文（待加密）</param>
        /// <param name="key">密文</param>
        /// <returns></returns>
        public static string AesEncrypt(string str, string key)
        {
            if (string.IsNullOrEmpty(str)) return null;
            Byte[] toEncryptArray = Encoding.UTF8.GetBytes(str);

            RijndaelManaged rm = new RijndaelManaged
            {
                Key = Encoding.UTF8.GetBytes(key),
                Mode = CipherMode.ECB,
                Padding = PaddingMode.PKCS7
            };

            ICryptoTransform cTransform = rm.CreateEncryptor();
            Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

            return System.Convert.ToBase64String(resultArray, 0, resultArray.Length);
        }

        /// <summary>
        ///  AES 解密
        /// </summary>
        /// <param name="str">明文（待解密）</param>
        /// <param name="key">密文</param>
        /// <returns></returns>
        public static string AesDecrypt(string str, string key)
        {
            if (string.IsNullOrEmpty(str)) return null;
            Byte[] toEncryptArray = System.Convert.FromBase64String(str);

            RijndaelManaged rm = new RijndaelManaged
            {
                Key = Encoding.UTF8.GetBytes(key),
                Mode = CipherMode.ECB,
                Padding = PaddingMode.PKCS7
            };

            ICryptoTransform cTransform = rm.CreateDecryptor();
            Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

            return Encoding.UTF8.GetString(resultArray);
        }

        public static string SerializeJsonString(object model, string GetKeyUrl)
        {
            string BodyJson = Newtonsoft.Json.JsonConvert.SerializeObject(model, Newtonsoft.Json.Formatting.Indented, new Newtonsoft.Json.JsonSerializerSettings { ContractResolver = new Newtonsoft.Json.Serialization.CamelCasePropertyNamesContractResolver() });
            BodyJson = BodyJson.Replace("\r\n", "");
            string AesKey = GetResultJson(GetKeyUrl);
            string AesBodyJson = AesEncrypt(BodyJson, AesKey);
            Dictionary<string, string> dictionary = new Dictionary<string, string>();
            dictionary.Add("json", AesBodyJson);
            string DictionaryJson = ConvertToBodyJson(dictionary);
            return DictionaryJson;
        }


        public static T ToJsonObject<T>(string src)
        {
            return Newtonsoft.Json.JsonConvert.DeserializeObject<T>(src);
        }

        /// <summary>
        /// 去掉Json中的空值并返回实体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="strJson"></param>
        /// <returns></returns>
        public static List<T> Json2Object<T>(string strJson)
        {
            JsonSerializerSettings jsonSetting = new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore };
            return JsonConvert.DeserializeObject<List<T>>(strJson, jsonSetting);
        }

鱼在一边，酒在一边
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
盘点C#实体类转换的两种方式
xinyuerr的博客
09-26 270
本文主要介绍了C#实体类转换的两种方式小结，具有很好的参考价值，希望对大家有所帮助。
json转换c#实体类代码
01-05
在.NET开发环境中，C#是一种常用的编程语言，而JSON（JavaScript Object Notation）则是一种轻量级的数据交换格式，广泛应用于Web服务和客户端之间的数据传输。将JSON转换为C#实体类是常见的需求，特别是在处理API...
C# JSON实体类生成工具
02-24
该工具支持通过在软件界面输入或者粘贴JSON字符串，根据字符串生成C#编程开发使用的JSON实体类文件。
C#实体类转换为JSON字符串
热门推荐
一出好剧
06-08 2万+
C#实体类转换为JSON 使用程序集：Newtonsoft.Json C#实体类转换为JSON 代码 关键 代码 不说二话，直接上代码 using System; // @author Simorel // https://blog.csdn.net/Simoral // 引用程序集： Newtonsoft.Json.dll using Newtonsoft...
C#中json数据序列化和反序列化的最简单方法（C#对象和字符串的相互转换）
hanmo22357的博客
05-14 1438
用最简短明了的方式介绍C#中如何基于Newtonsoft模块进行C#对象和json字符串之间的相互转换
C# JSON转为实体类和List，以及结合使用
munangs的博客
10-20 4490
C# JSON转为实体类和List，以及结合使用
C#实体对象序列化成Json，格式化，并让字段的首字母小写
weixin_30721899的博客
02-01 344
解决办法有两种：第一种：使用对象的字段属性设置JsonProperty来实现（不推荐，因为需要手动的修改每个字段的属性） public class UserInfo { [JsonProperty("id")] public int Id{ set; get; } [JsonProperty("userName")] public string ...
json 中有递归parentId节点转 c#实体类时如何处理
nbspzs的专栏
04-28 729
json 中有递归parentId节点转 c#实体类时如何处理
C#实现XML与实体类之间相互转换的方法(序列化与反序列化)
09-02
在C#编程中，XML（eXtensible Markup Language）是一种常用的数据交换格式，它可以用于存储和传输数据。为了在C#程序中处理XML数据，我们通常会利用序列化和反序列化技术将XML字符串与实体类（自定义对象）进行相互...
C#操作 JSON方法汇总
01-20
要将这样的JSON字符串反序列化为C#对象，你需要先创建一个对应的实体类。例如，对于上面的JSON，你可以创建一个名为`Person`的类： ```csharp public class Person { public string FirstName { get; set; } ...
C#JSON转换实体类实例
05-12
在C#中处理JSON时，经常会用到一个第三方库——Newtonsoft.Json，它提供了丰富的API来帮助我们将JSON字符串转换为C#中的实体类对象，反之亦然。本文将详细介绍如何使用Newtonsoft.Json库进行JSON与实体类之间的转换...
Json字符串生成实体对象工具
12-13
通过Json 字符串，自动生成C# 对应的实体类，需要源码请联系
【C#进阶八】C#中的序列化与反序列化下（二进制序列化、XML序列化及JSON序列化）
QHCV的博客
08-30 613
序列化是指将对象转换成字节流，从而存储对象或将对象传输到内存、数据库或文件的过程。 它的主要用途是保存对象的状态，以便能够在需要时重新创建对象。 反向过程称为“反序列化”。
序列化之二进制与JSON
Acettest's Blogs
05-22 1万+
1.什么是序列化 我们把变量从内存中变成可存储或传输的过程称之为序列化2.为什么要序列化 根本原因：需要将变量或对象从内存中取出来进行存储或传输3.具体应用： 1)对象保存到文件或数据库 2)网络编程时对象跨平台跨语言传输，也即从windows上序列化的对象可到linux上返序列化，用c＃序列化的对象可以被java反序列化。4.序列化的形式： 1)二进制序列化器BinaryFormatter，主要...
C# 对象 和 Json 各种转换
昔木的博客
08-16 354
C#Json转换List 第二篇，直接进入正题 对象转Json 我这边为了方便，用txt存放json，直接读取。 引用如下： using Newtonsoft.Json; using Newtonsoft.Json.Linq; 添加引用： 右键项目-》管理NuGet程序包-》浏览-》搜索：Newtonsoft，根据自己的程序框架选择对应的版本 如果搜索不出就把程序包源切换到：nuget.org：...
牛啊牛啊：C#/.NET一行代码把实体类类型转换为Json数据字符串
最新发布
WeskyNet
06-05 305
前言：刚好要做一个类似Swagger那种可以快速访问api接口和演示的功能，于是就把做的思路写到包里面去，给有需要的小伙伴提供学习和参考。首先，安装1.0.10以及以上版本的 Wesky.Net.OpenTools 包包内，该功能的核心代码如下：自定义属性：实体类JSON模式生成器：使用方式：引用上面的1.0.10版本或以上的包。如果实体类有特殊需求，例如映射为其他名称，可以用OpenJson属性...
【小5聊】C# Json字符串转Model实体类以及Model实体类转Json字符串
小5聊的博客
11-12 1690
1、引用DLL：Newtonsoft.Json.dll 引用自己项目兼容的dll版本安装 2、Json字符串转Model实体类 UserInfoModel model = new UserInfoModel(); model = JsonConvert.DeserializeObject<UserInfoModel>(msg); 3、Model实体类转Json ......
【C#】基于JsonConvert解析Json数据
little_fat_sheep
12-02 1万+
本文基于JsonConvert解析Json数据，主要讲解了Json字典串解析、一维Json数组串解析、二维Json数组串解析、数组字典Json混合串解析、字典数组Json混合串解析、Json文件解析。
C# json转实体类
我的博客
11-22 7426
C# 模拟json数据 需要引用 Newtonsoft.dll using Newtonsoft.Json; using Newtonsoft.Json.Linq; JObject source = new JObject(); //{"SOURCE":108,"TABLENAME":"MV_GSJ_BGDJ","SOURCE_TABLENAME":"工商变更登记信息","DB.
c#如何把json文件转成实体类
06-13
在 C# 中，可以使用 Newtonsoft.Json 库来将 JSON 文件转换为实体类。您可以按照以下步骤来实现： 1. 在 Visual Studio 中，添加一个新的类文件，并定义一个与 JSON 文件中的字段对应的实体类。 例如，如果您的 JSON 文件中包含以下内容： ```json { "name": "John", "age": 30, "address": { "street": "123 Main St", "city": "Anytown", "state": "CA" } } ``` 那么您可以定义一个名为 Person 的实体类： ```csharp public class Person { public string Name { get; set; } public int Age { get; set; } public Address Address { get; set; } } public class Address { public string Street { get; set; } public string City { get; set; } public string State { get; set; } } ``` 2. 在代码中，使用 Newtonsoft.Json 库来读取 JSON 文件，并将其转换为实体类的对象。 ```csharp string json = File.ReadAllText("path/to/json/file.json"); var person = JsonConvert.DeserializeObject<Person>(json); ``` 这样，您就可以使用 person 对象来访问 JSON 文件中的字段了。注意，您需要将“path/to/json/file.json”替换为您自己的 JSON 文件的路径。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值