Xml/Json与实体的相互转换

1.先引用DLL（Newtonsoft.Json.dll），已上传DLL

/*************************************************
 * 描述：
 * 
 * Author：yuanshuo
 * Date：2021/11/15 17:14:59
 * Update：
 * ************************************************/

using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Serialization;

namespace Common.DataConversion_Helper
{
    /// <summary>
    /// 数据转换操作(XML\Json与实体类的相互转换
    /// </summary>
    public class ConverOper
    {
        #region  Xml相关
        /// <summary>
        /// 序列化xml
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static string GetXmlByObjet<T>(T obj)
        {
            try
            {
                using (StringWriter sw = new StringWriter())
                {
                    Type t = obj.GetType();
                    XmlSerializer serializer = new XmlSerializer(obj.GetType());
                    serializer.Serialize(sw, obj);
                    sw.Close();
                    return sw.ToString();
                }
            }
            catch (Exception ex)
            {
                string text = $"实体序列化xml失败；失败原因：{ex.Message}";
                return text;
            }

        }


        /// <summary>
        /// 反序列化xml
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="strXML"></param>
        /// <returns></returns>
        public static T GetTByXml<T>(string strXML) where T : class
        {
            try
            {
                using (StringReader sr = new StringReader(strXML))
                {
                    XmlSerializer serializer = new XmlSerializer(typeof(T));
                    return serializer.Deserialize(sr) as T;
                }
            }
            catch (Exception ex)
            {
                //string text=$"xml反序列化实体失败{ex} ";
                return null;
            }
        }


        /// <summary>
        /// 格式化xml
        /// </summary>
        /// <param name="xml"></param>
        /// <returns></returns>
        public static string GetXmlByFormat(string xml)
        {
            string resultXml = xml;
            try
            {
                XmlDocument doc = new XmlDocument();
                doc.LoadXml(xml);

                System.IO.StringWriter sw = new System.IO.StringWriter();
                using (System.Xml.XmlTextWriter writer = new System.Xml.XmlTextWriter(sw))
                {
                    writer.Indentation = 2;  // the Indentation
                    writer.Formatting = System.Xml.Formatting.Indented;
                    doc.WriteContentTo(writer);
                    writer.Close();
                }
                resultXml = sw.ToString();
            }
            catch (Exception ex)
            {
                resultXml = $"格式化xmlm出错:{ex.Message}";
            }
            return resultXml;
        }


        /// <summary>
        /// 解析XML,匹配替换模板中的内容
        /// </summary>
        /// <param name="content">模板内容</param>
        /// <param name="obj">模板对应的对象</param>
        /// <param name="GetType">模板对应的对象的类的类型</param>
        /// <returns></returns>
        public static string ParseXML(string content, object obj, Type GetType)
        {
            //结束贪婪模式
            Regex r = new Regex(@"\{(\w+?)\}");
            MatchCollection matches = r.Matches(content);
            foreach (Match matche in matches)
            {
                #region 匹配替换
                //提取组
                Group g = matche.Groups[1];
                //属性名
                string key = g.Value;
                //属性
                var property = GetType.GetProperty(key);
                //属性里面的值
                string value = "";
                if (property != null)
                {
                    object proobj = property.GetValue(obj, null);
                    if (proobj != null)
                    {
                        value = proobj.ToString();
                    }
                }
                else
                {
                    string nullstr = "";
                }
                Regex r1 = new Regex(@"\{" + key + @"\}");
                content = r1.Replace(content, value);
                #endregion
            }
            return content;
        }


        #endregion Xml相关

        #region  Json相关
        private static JsonSerializerSettings InitSettings(bool camelCasePropertyName)
        {
            JsonSerializerSettings jsonSerializerSettings = new JsonSerializerSettings();
            JsonConvert.DefaultSettings = new Func<JsonSerializerSettings>(() =>
            {
                //日期类型默认格式化处理  
                jsonSerializerSettings.DateFormatHandling = DateFormatHandling.IsoDateFormat;
                jsonSerializerSettings.DateFormatString = "yyyy-MM-ddTHH:mm:ss.fff";

                if (camelCasePropertyName)
                {
                    //序列化时 指定Key的处理方式，为驼峰式
                    jsonSerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
                }
                jsonSerializerSettings.Formatting = Newtonsoft.Json.Formatting.None;

                //忽略值为空的属性
                jsonSerializerSettings.NullValueHandling = NullValueHandling.Ignore;

                return jsonSerializerSettings;
            });

            return jsonSerializerSettings;
        }

        /// <summary>
        /// 序列化对象到JSON字符串
        /// </summary>
        /// <param name="value">待序列化的对象</param>
        /// <returns>序列化后的JSON字符串</returns>
        public static string GetJsonByObject(object value)
        {
            return JsonConvert.SerializeObject(value, InitSettings(false));
        }

        /// <summary>
        /// 序列化对象到JSON字符串，指定Key的处理方式为驼峰命名法
        /// </summary>
        /// <param name="value">待序列化的对象</param>
        /// <returns>序列化后的JSON字符串</returns>
        public static string GetJsonByObjectCamelCase(object value)
        {
            return JsonConvert.SerializeObject(value, InitSettings(true));
        }

        /// <summary>
        /// 反序列化JSON字符串到实体对象
        /// </summary>
        /// <typeparam name="T">实体对象类型</typeparam>
        /// <param name="json">待反序列化的JSON字符串</param>
        /// <returns>反序列化后的实体对象</returns>
        public static T GetEntityByJson<T>(string json)
        {
            return json == null ? default(T) : JsonConvert.DeserializeObject<T>(json, InitSettings(false));
        }

        /// <summary>
        /// 反序列化JSON字符串到实体对象，指定Key的处理方式为驼峰命名法
        /// </summary>
        /// <typeparam name="T">实体对象类型</typeparam>
        /// <param name="json">待反序列化的JSON字符串</param>
        /// <returns>反序列化后的实体对象</returns>
        public static T GetEntityByJsonCamelCase<T>(string json)
        {
            return json == null ? default(T) : JsonConvert.DeserializeObject<T>(json, InitSettings(true));
        }

        /// <summary>
        /// 反序列化JSON字符串到对象
        /// </summary>
        /// <param name="json">待反序列化的JSON字符串</param>
        /// <returns>反序列化后的对象</returns>
        public static object GetObjectByJson(string json)
        {
            return json == null ? null : JsonConvert.DeserializeObject(json, InitSettings(false));
        }

        /// <summary>
        /// 反序列化JSON字符串到对象，指定Key的处理方式为驼峰命名法
        /// </summary>
        /// <param name="json">待反序列化的JSON字符串</param>
        /// <returns>反序列化后的对象</returns>
        public static object GetObjectByJsonCamelCase(string json)
        {
            return json == null ? null : JsonConvert.DeserializeObject(json, InitSettings(true));
        }
       
        #endregion json相关

    }
}