C# 利用 Newtonsoft.Json 实现 Json 字符串 与 Object 对象数据 的转换

废话不多说，直接上干货！

首先，需要在项目中引用 Newtonsoft.Json 库，

选中你在开发的项目，右键（如下图，VS2017 IDE）

搜索 Json ，

 安装 Newtonsoft.Json 库 即可。

下面是一个 Json 的工具类代码：

using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Common.Json
{
    /// <summary> Json 工具类
    /// </summary>
    public static class JsonTool
    {

        /// <summary> 设置 Json 序列化格式
        /// </summary>
        /// <param name="isFormatJson">是否格式化 Json 字符串，默认 true</param>
        /// <param name="isIgnoreNull">是否忽略 null 值，默认 false</param>
        /// <param name="DtmFormat">日期格式化参数，默认 "yyyy-MM-dd HH:mm:ss"</param>
        /// <returns></returns>
        public static JsonSerializerSettings SetJsonSerializerFormat(bool isFormatJson = true,
                                                                     bool isIgnoreNull = false,
                                                                     string DtmFormat = "yyyy-MM-dd HH:mm:ss")
        {
            JsonSerializerSettings jss = new JsonSerializerSettings();

            IList<JsonConverter> jcList = new List<JsonConverter>();

            //日期时间格式化处理
            IsoDateTimeConverter timeConverter = new IsoDateTimeConverter();
            timeConverter.DateTimeFormat = DtmFormat; //日期时间格式化处理

            jcList.Add(timeConverter);

            jss.Converters = jcList;

            if (isFormatJson)
            {
                jss.Formatting = Newtonsoft.Json.Formatting.Indented; //格式化Json字符串    
            }

            if (isIgnoreNull)
            {
                jss.NullValueHandling = NullValueHandling.Ignore; //忽略null值    
            }

            return jss;
        }

        /// <summary> object 对象转换为 Json 字符串
        /// </summary>
        /// <param name="obj">可序列化对象</param>
        /// <returns></returns>
        public static string ObjectToJson(object obj)
        {
            string json = null;

            if (obj == null)
            {
                return string.Empty;
            }

            try
            {
                json = JsonConvert.SerializeObject(obj, SetJsonSerializerFormat());
            }
            catch (Exception ex)
            {
                return string.Empty;
            }

            return json;
        }

        /// <summary> Json 格式的字符串转换为 T 对象
        /// </summary>
        /// <typeparam name="T">泛型 类型</typeparam>
        /// <param name="json">json 格式的字符串</param>
        /// <returns></returns>
        public static T JsonToObject<T>(string json)
        {
            T t_object = default(T);

            if (string.IsNullOrWhiteSpace(json))
            {
                return default(T);
            }

            try
            {
                t_object = JsonConvert.DeserializeObject<T>(json);
            }
            catch (Exception ex)
            {
                return default(T);
            }

            return t_object;
        }

        /// <summary> Json 格式的字符串转换为 object 对象
        /// </summary>
        /// <param name="json">json 格式的字符串</param>
        /// <returns></returns>
        public static object JsonToObject(string json)
        {
            object obj = null;

            if (string.IsNullOrWhiteSpace(json))
            {
                return null;
            }

            try
            {
                obj = JsonConvert.DeserializeObject(json);
            }
            catch (Exception ex)
            {
                return null;
            }

            return obj;
        }

        /// <summary> Json 格式的字符串转换为 dynamic 匿名对象
        /// </summary>
        /// <param name="json">json 格式的字符串</param>
        /// <returns></returns>
        public static dynamic JsonToDynamic(string json)
        {
            if (string.IsNullOrWhiteSpace(json))
            {
                return null;
            }

            //创建匿名对象
            dynamic dyData = default(dynamic);

            try
            {
                dyData = JsonConvert.DeserializeObject(json);
            }
            catch (Exception ex)
            {
                dyData = null;
            }

            return dyData;
        }


        /// <summary> 读取 Json 内容的文件，并转化为 object 对象
        /// </summary>
        /// <param name="path">Json 文件的绝对路径</param>
        /// <param name="encoding">字符编码，默认 UTF-8</param>
        /// <returns></returns>
        public static object JsonFileToObject(string path, Encoding encoding = null)
        {
            if (!File.Exists(path))
            {
                return null;
            }

            object obj = null;

            if (encoding == null)
            {
                encoding = Encoding.UTF8;
            }

            try
            {
                string jsonStr = null;
                using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read))
                {
                    using (StreamReader sr = new StreamReader(fs, encoding))
                    {
                        jsonStr = sr.ReadToEnd();
                    }
                }
                if (string.IsNullOrWhiteSpace(jsonStr))
                {
                    obj = null;
                }
                else
                {
                    obj = JsonToObject(jsonStr);
                }
            }
            catch (Exception ex)
            {
                obj = null;
            }

            return obj;
        }

        /// <summary> 读取 Json 内容的文件，并转化为 T 对象
        /// </summary>
        /// <typeparam name="T">泛型 类型</typeparam>
        /// <param name="path">Json 文件的绝对路径</param>
        /// <param name="encoding">字符编码，默认 UTF-8</param>
        /// <returns></returns>
        public static T JsonFileToObject<T>(string path, Encoding encoding = null)
        {
            T t_obj = default(T);

            if (!File.Exists(path))
            {
                return default(T);
            }

            if (encoding == null)
            {
                encoding = Encoding.UTF8;
            }

            try
            {
                string jsonStr = null;
                using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read))
                {
                    using (StreamReader sr = new StreamReader(fs, encoding))
                    {
                        jsonStr = sr.ReadToEnd();
                    }
                }
                if (string.IsNullOrWhiteSpace(jsonStr))
                {
                    t_obj = default(T);
                }
                else
                {
                    t_obj = JsonToObject<T>(jsonStr);
                }
            }
            catch (Exception ex)
            {
                t_obj = default(T);
            }

            return t_obj;
        }

        /// <summary> object 对象转换为 Json 内容的文件
        /// </summary>
        /// <param name="obj">object</param>
        /// <param name="path">Json 文件的绝对路径（建议文件格式用 .json 后缀）</param>
        /// <param name="encoding">字符编码，默认 UTF-8</param>
        /// <returns></returns>
        public static bool ObjectToJsonFile(object obj, string path, Encoding encoding = null)
        {
            if (obj == null || string.IsNullOrWhiteSpace(path))
            {
                return false;
            }

            bool isFinish = false;

            string jsonStr = ObjectToJson(obj);
            if (string.IsNullOrWhiteSpace(jsonStr))
            {
                isFinish = false;
            }
            else
            {
                if (encoding == null)
                {
                    encoding = Encoding.UTF8;
                }
                try
                {
                    if (!Directory.Exists(Path.GetDirectoryName(path)))
                    {
                        Directory.CreateDirectory(Path.GetDirectoryName(path));
                    }

                    using (FileStream fs = new FileStream(path, FileMode.Create, FileAccess.Write))
                    {
                        using (StreamWriter sw = new StreamWriter(fs, encoding))
                        {
                            sw.Write(jsonStr);
                        }
                    }
                    isFinish = true;
                }
                catch (Exception ex)
                {
                    isFinish = false;
                }
            }

            return isFinish;
        }

    }
}

希望给你带来帮助！