JSON扩展类——JsonHelper
1.引用Newtonsoft.Json库（JSON.NET）。
2.复制粘贴JsonHelper吧。
源代码：
using System;
using System.Collections.Generic;
using System.Linq;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
namespace Allen.Core
{
public static partial class JsonHelper
{
#region Private fields
private static readonly JsonSerializerSettings JsonSettings;
private const string EmptyJson = "[]";
#endregion
#region Constructor
static JsonHelper()
{
var datetimeConverter = new IsoDateTimeConverter { DateTimeFormat = "yyyy-MM-dd HH:mm:ss" };
JsonSettings = new JsonSerializerSettings
{
MissingMemberHandling = MissingMemberHandling.Ignore,
NullValueHandling = NullValueHandling.Ignore,
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
};
JsonSettings.Converters.Add(datetimeConverter);
}
#endregion
#region Public Methods
/// <summary>
/// 应用Formatting.None和指定的JsonSerializerSettings设置,序列化对象到JSON格式的字符串
/// </summary>
/// <param name="obj">任意一个对象</param>
/// <param name="jsonSettings">在一个 Newtonsoft.Json.JsonSerializer 对象上指定设置，如果为null，则使用默认设置</param>
/// <returns>标准的JSON格式的字符串</returns>
public static string ToJson(object obj, JsonSerializerSettings jsonSettings)
{
return ToJson(obj, Formatting.None, jsonSettings);
}
/// <summary>
/// 应用指定的Formatting枚举值None和指定的JsonSerializerSettings设置,序列化对象到JSON格式的字符串
/// </summary>
/// <param name="obj">任意一个对象</param>
/// <param name="format">指定 Newtonsoft.Json.JsonTextWriter 的格式设置选项</param>
/// <param name="jsonSettings">在一个 Newtonsoft.Json.JsonSerializer 对象上指定设置，如果为null，则使用默认设置</param>
/// <returns>标准的JSON格式的字符串</returns>
public static string ToJson(object obj, Formatting format, JsonSerializerSettings jsonSettings)
{
try
{
return obj == null ? EmptyJson : JsonConvert.SerializeObject(obj, format, jsonSettings ?? JsonSettings);
}
catch (Exception)
{
//TODO LOG
return EmptyJson;
}
}
/// <summary>
/// 应用Formatting.None和指定的JsonSerializerSettings设置,反序列化JSON数据为dynamic对象
/// <para>如果发生JsonSerializationException异常，再以集合的方式重试一次，取出集合的第一个dynamic对象。</para>
/// <para>转换失败，或发生其它异常，则返回dynamic对象的默认值</para>
/// </summary>
/// <param name="json">需要反序列化的JSON字符串</param>
/// <param name="jsonSettings">在一个 Newtonsoft.Json.JsonSerializer 对象上指定设置，如果为null，则使用默认设置</param>
/// <returns>dynamic对象</returns>
public static dynamic FromJson(this string json, JsonSerializerSettings jsonSettings)
{
return FromJson<dynamic>(json, Formatting.None, jsonSettings);
}
/// <summary>
/// 应用指定的Formatting枚举值None和指定的JsonSerializerSettings设置,反序列化JSON数据为dynamic对象
/// <para>如果发生JsonSerializationException异常，再以集合的方式重试一次，取出集合的第一个dynamic对象。</para>
/// <para>转换失败，或发生其它异常，则返回dynamic对象的默认值</para>
/// </summary>
/// <param name="json">需要反序列化的JSON字符串</param>
/// <param name="format">指定 Newtonsoft.Json.JsonTextWriter 的格式设置选项</param>
/// <param name="jsonSettings">在一个 Newtonsoft.Json.JsonSerializer 对象上指定设置，如果为null，则使用默认设置</param>
/// <returns>dynamic对象</returns>
public static dynamic FromJson(this string json, Formatting format, JsonSerializerSettings jsonSettings)
{
return FromJson<dynamic>(json, format, jsonSettings);
}
/// <summary>
/// 应用Formatting.None和指定的JsonSerializerSettings设置,反序列化JSON数据到指定的.NET类型对象
/// <para>如果发生JsonSerializationException异常，再以集合的方式重试一次，取出集合的第一个T对象。</para>
/// <para>转换失败，或发生其它异常，则返回T对象的默认值</para>
/// </summary>
/// <param name="json">需要反序列化的JSON字符串</param>
/// <param name="jsonSettings">在一个 Newtonsoft.Json.JsonSerializer 对象上指定设置，如果为null，则使用默认设置</param>
/// <typeparam name="T">反序列化对象的类型</typeparam>
/// <returns></returns>
public static T FromJson<T>(string json, JsonSerializerSettings jsonSettings) where T : class, new()
{
return FromJson<T>(json, Formatting.None, jsonSettings);
}
/// <summary>
/// 应用指定的Formatting枚举值None和指定的JsonSerializerSettings设置,反序列化JSON数据到指定的.NET类型对象
/// <para>如果发生JsonSerializationException异常，再以集合的方式重试一次，取出集合的第一个T对象。</para>
/// <para>转换失败，或发生其它异常，则返回T对象的默认值</para>
/// </summary>
/// <param name="json">需要反序列化的JSON字符串</param>
/// <param name="format">指定 Newtonsoft.Json.JsonTextWriter 的格式设置选项</param>
/// <param name="jsonSettings">在一个 Newtonsoft.Json.JsonSerializer 对象上指定设置，如果为null，则使用默认设置</param>
/// <typeparam name="T">反序列化对象的类型</typeparam>
/// <returns></returns>
public static T FromJson<T>(string json, Formatting format, JsonSerializerSettings jsonSettings) where T : class, new()
{
T result;
if (jsonSettings == null)
{
jsonSettings = JsonSettings;
}
try
{
result = string.IsNullOrWhiteSpace(json) ? default(T) : JsonConvert.DeserializeObject<T>(json, jsonSettings);
}
catch (JsonSerializationException) //在发生该异常后，再以集合的方式重试一次.
{
//LOG
try
{
var array = JsonConvert.DeserializeObject<IEnumerable<T>>(json, jsonSettings);
result = array.FirstOrDefault();
}
catch (Exception)
{
//LOG
result = default(T);
}
}
catch (Exception)
{
//LOG
result = default(T);
}
return result;
}
#endregion
#region Public Extend Methods
/// <summary>
/// 反序列化JSON数据为dynamic对象
/// <para>如果发生JsonSerializationException异常，再以集合的方式重试一次，取出集合的第一个dynamic对象。</para>
/// <para>转换失败，或发生其它异常，则返回dynamic对象的默认值</para>
/// </summary>
/// <param name="json">需要反序列化的JSON字符串</param>
/// <returns>dynamic对象</returns>
public static dynamic FromJson(this string json)
{
return FromJson<dynamic>(json, Formatting.None, JsonSettings);
}
/// <summary>
/// 反序列化JSON数据到指定的.NET类型对象
/// <para>如果发生JsonSerializationException异常，再以集合的方式重试一次，取出集合的第一个T对象。</para>
/// <para>转换失败，或发生其它异常，则返回T对象的默认值</para>
/// </summary>
/// <param name="json">需要反序列化的JSON字符串</param>
/// <typeparam name="T">反序列化对象的类型</typeparam>
/// <returns></returns>
public static T FromJson<T>(this string json) where T : class, new()
{
return FromJson<T>(json, Formatting.None, JsonSettings);
}
/// <summary>
/// 应用默认的Formatting枚举值None和默认的JsonSerializerSettings设置,序列化对象到JSON格式的字符串
/// </summary>
/// <param name="obj">任意一个对象</param>
/// <returns>标准的JSON格式的字符串</returns>
public static string ToJson(this object obj)
{
return ToJson(obj, Formatting.None, JsonSettings);
}
public static string ToJson<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, bool isFilterNull = true)
{
return DelegateToJson(source, enumerable => enumerable.Where(predicate), isFilterNull);
}
public static string ToJson<TSource>(this IEnumerable<TSource> source, Func<TSource, int, bool> predicate, bool isFilterNull = true)
{
return DelegateToJson(source, enumerable => enumerable.Where(predicate), isFilterNull);
}
public static string ToJson<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector, bool isFilterNull = true)
{
return DelegateToJson(source, enumerable => enumerable.Where(t => t != null).Select(selector), isFilterNull);
}
public static string ToJson<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, int, TResult> selector, bool isFilterNull = true)
{
return DelegateToJson(source, enumerable => enumerable.Where(t => t != null).Select(selector), isFilterNull);
}
public static string ToJson<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, TResult> selector, bool isFilterNull = true)
{
return DelegateToJson(source, enumerable => enumerable.Where(predicate).Select(selector), isFilterNull);
}
public static string ToJson<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, int, TResult> selector, bool isFilterNull = true)
{
return DelegateToJson(source, enumerable => enumerable.Where(predicate).Select(selector), isFilterNull);
}
public static string ToJson<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, int, bool> predicate, Func<TSource, TResult> selector, bool isFilterNull = true)
{
return DelegateToJson(source, enumerable => enumerable.Where(predicate).Select(selector), isFilterNull);
}
public static string ToJson<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, int, bool> predicate, Func<TSource, int, TResult> selector, bool isFilterNull = true)
{
return DelegateToJson(source, enumerable => enumerable.Where(predicate).Select(selector), isFilterNull);
}
#endregion
#region Private Methods
/// <summary>
/// 委托处理需要序列化为JSON格式的对象，返回标准的JSON格式的字符串。
/// 默认过滤null对象，如果需要在上层调用时，自己进行条件过滤null对象，
/// 则设置isFilterNull为false，不建议isFilterNull设置为false。
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <typeparam name="TResult"></typeparam>
/// <param name="source">需要转换为JSON格式字符串的对象</param>
/// <param name="func">集合/数组条件筛选方法委托，返回筛选后的集合/数组</param>
/// <param name="isFilterNull">是否过滤IEnumerable<TSource> source中的null对象，默认为true</param>
/// <returns>标准的JSON格式的字符串</returns>
private static string DelegateToJson<TSource, TResult>(IEnumerable<TSource> source, Func<TSource[], IEnumerable<TResult>> func, bool isFilterNull = true)
{
return DelegateToJson(source, enumerable => func(enumerable).ToJson(), isFilterNull);
}
/// <summary>
/// 委托处理需要序列化为JSON格式的对象，返回标准的JSON格式的字符串。
/// 默认过滤null对象，如果需要在上层调用时，自己进行条件过滤null对象，
/// 则设置isFilterNull为false，不建议isFilterNull设置为false。
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <param name="source">需要转换为JSON格式字符串的对象</param>
/// <param name="func">JSON处理方法委托，返回JSON格式的字符串</param>
/// <param name="isFilterNull">是否过滤IEnumerable<TSource> source中的null对象，默认为true</param>
/// <returns>标准的JSON格式的字符串</returns>
private static string DelegateToJson<TSource>(IEnumerable<TSource> source, Func<TSource[], string> func, bool isFilterNull = true)
{
if (source == null)
{
return EmptyJson;
}
TSource[] enumerable;
if (isFilterNull)
{
//过滤null
enumerable = source.Where(t => t != null).ToArray();
}
else
{
//不过滤null，但上层需要注意内里面有null对象时，可能会导致Where或Select引发异常。
enumerable = source as TSource[] ?? source.ToArray();
}
return enumerable.Any() ? func(enumerable) : EmptyJson;
}
#endregion
}
}
用法案例：
class Program
{
static void Main(string[] args)
{
//ToJson 方法 Test
#region 默认过滤null对象
var list1 = new List<Test>
{
new Test {Id = 10, Type = 21, Name="Allen"},
new Test {Id = 11, Type = 22},
new Test {Id = 12, Type = 23},
new Test {Id = 13, Type = 24, Name="Peter"},
null,
new Test {Id = 13, Type = 24, Name=null}
};
//指定json数据所需要的属性
string jsonString = list1.ToJson(t => new { id = t.Id, type = t.Type }); //推荐写法，连true都省略掉
//string jsonString = JsonHelper.ToJson(list1, t => new { id = t.Id, type = t.Type }); //不推荐该写法
//string jsonString = list1.ToJson(t => new { id = t.Id, type = t.Type }, true);
Console.WriteLine(jsonString);
//筛选出Name为"Allen"的对象
string jsonString2 = list1.ToJson(t => t.Name == "Allen"); //推荐写法，连true都省略掉
//string jsonString2 = JsonHelper.ToJson(list1, t => t.Name == "Allen"); //不推荐该写法
//string jsonString2 = list1.ToJson(t => t.Name == "Allen", true);
Console.WriteLine(jsonString2);
//筛选出Name为"Allen"的对象，并且指定json数据所需要的属性
string jsonString3 = list1.ToJson(t => t.Name == "Allen", t => new { id = t.Id, type = t.Type }); //推荐写法，连true都省略掉
//string jsonString3 = JsonHelper.ToJson(list1, t => t.Name == "Allen", t => new { id = t.Id, type = t.Type }); //不推荐该写法
//string jsonString3 = list1.ToJson(t => t.Name == "Allen", t => new { id = t.Id, type = t.Type }, true);
Console.WriteLine(jsonString3);
#endregion
#region 不过滤null对象
var list2 = new List<Test>
{
new Test {Id = 10, Type = 21, Name="Allen"},
new Test {Id = 11, Type = 22, Name="Bolong"},
new Test {Id = 12, Type = 23, Name="Popo"},
new Test {Id = 13, Type = 24, Name="Peter"},
new Test {Id = 16, Type = 25, Name="Willy"}
};
//指定json数据所需要的属性
string jsonString4 = list2.ToJson(t => new { id = t.Id, type = t.Type }, false);
Console.WriteLine(jsonString4);
//筛选出Name为"Allen"的对象
string jsonString5 = list2.ToJson(t => t.Name == "Allen", false);
Console.WriteLine(jsonString5);
//筛选出Name为"Allen"的对象，并且指定json数据所需要的属性
string jsonString6 = list2.ToJson(t => t.Name == "Allen", t => new { id = t.Id, type = t.Type }, false);
Console.WriteLine(jsonString6);
#endregion
//FromJson<T> 方法 Test
List<Test> testList1 = jsonString.FromJson<List<Test>>();
List<Test> testList2 = jsonString2.FromJson<List<Test>>();
Test test = jsonString3.FromJson<Test>();
//弱类型 Test
var test2 = jsonString.FromJson();
Newtonsoft.Json.Linq.JArray test3 = test2;
Console.ReadKey();
}
}
internal class Test
{
public int Type { get; set; }
public int Id { get; set; }
public string Name { get; set; }
}
PS：有更好的封装建议吗？