Newtonsoft.Json对象转JSON字符串全集

需求：对象转为JSON字符串时可以同时满足以下5点。

1、同一个类中不同字段支持自定义日期格式，如：“2024-10-01”，“2024-10-01 12:12:12”；

2、string、datetime 为null时转为空字符串；int、decimal为null时转为0；对象为null时转为{}；集合为null时转为[]； （PS：.Net8中Newtonsoft日期类型不支持空字符串）

3、long类型可以转为字符串；

4、枚举可以用“value、name、display” 做为json字符串的值；

5、小数点可以保留完整。

测试环境：

.Net5,.Net8

现实如下：

第1/3步：自定义ActionResult

public class CustomsJsonResult : ActionResult
{

    public object Value { get; private set; }  
    public string ContentType { get;  set; }
    public CustomsJsonResult(object _value){

        Value = _value;
    }
    /// <summary>
    /// 时间默认格式
    /// </summary>
    public string formatter = "yyyy-MM-dd HH:mm:ss";

    /// <summary>
    ///枚举转换
    /// </summary>
    public bool StringEnumConverter = false;
    public override void ExecuteResult(ActionContext context)
    {
        if (context == null)
        {
            context.HttpContext.Response.WriteAsync("{}");
        }
        var response = context.HttpContext.Response;
         response.ContentType =  string.IsNullOrEmpty(ContentType) ? "application/json": ContentType;
        var jsonSerizlizerSetting = new JsonSerializerSettings() {
            //设置取消循环引用
            MissingMemberHandling = MissingMemberHandling.Ignore,
            ReferenceLoopHandling = ReferenceLoopHandling.Ignore,

            //设置日期的格式为：yyyy-MM-dd
            DateFormatString = formatter,
          

            //自定义的解析协议
            ContractResolver = new NullToEmptyStringResolver()
           
        };

        if (StringEnumConverter)
        {
            //转换枚举
            CamelCaseNamingStrategy _CamelCaseNamingStrategy = new CamelCaseNamingStrategy { ProcessExtensionDataNames = true };
            //转换时使用枚举jsonProperty    [JsonConverter(typeof(EnumPropertyNameConverter)]
            jsonSerizlizerSetting.Converters.Add(new Models.EnumPropertyNameConverter { });
            //数字转为字符串  [JsonConverter(typeof(StringEnumConverter)]
            jsonSerizlizerSetting.Converters.Add(new StringEnumConverter { NamingStrategy = _CamelCaseNamingStrategy });
        }
        //日期转换格式
        jsonSerizlizerSetting.Converters.Add(new DateTimeFormat());//默认时间格式处理
        jsonSerizlizerSetting.Converters.Add(new DateFormat());//默认时间格式处理
        //时间转换格式
        //long转为字符串
        jsonSerizlizerSetting.Converters.Add(new Models.NumberToStrConverter { });
        //jsonSerizlizerSetting.Converters.Add(new DecimalPrecisionConverter(6));
   
        //序列化CardData出现内存溢出
        var json = JsonConvert.SerializeObject(Value, Formatting.None, jsonSerizlizerSetting);
        context.HttpContext.Response.WriteAsync(json);
    }

}

第2/3步：自定义解析协议，这里主要实现null转换。

    /// <summary>
    /// JSON自定义解析协议
    /// </summary>
    public class NullToEmptyStringResolver : Newtonsoft.Json.Serialization.DefaultContractResolver
    {
        protected override IValueProvider CreateMemberValueProvider(System.Reflection.MemberInfo member)
        {
            if (member.MemberType == MemberTypes.Property)
            {
                var pi = (PropertyInfo)member;
                if (
                pi.PropertyType == typeof(string)
                     || pi.PropertyType.BaseType == typeof(object)
                    || pi.PropertyType == typeof(DateTime)
                    || pi.PropertyType == typeof(DateTime?)
                    || pi.PropertyType == typeof(decimal?)
                    )
                {
                    return new NullableJsonValueProvider(pi);
                }
            }
            return base.CreateMemberValueProvider(member);
        }
    }


    //    protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
    //    {
    //        return type.GetProperties()
    //                .Select(p => {
    //                    var jp = base.CreateProperty(p, memberSerialization);
    //                    jp.ValueProvider = new NullToEmptyStringValueProvider(p);
    //                    return jp;
    //                }).ToList();
    //    }
    //}


    /// <summary>
    ///空值序列化提供程序
    /// </summary>
    public class NullableJsonValueProvider : IValueProvider
    {
        private static readonly string _defaultValue = string.Empty;

        private readonly PropertyInfo _propertyInfo;

        public NullableJsonValueProvider(PropertyInfo propertyInfo)
        {
            _propertyInfo = propertyInfo;
        }

        public void SetValue(object target, object value)
        {
            _propertyInfo.SetValue(target, value);
        }

        public object GetValue(object target)
        {
            var result = _propertyInfo.GetValue(target);
            if (result != null)
            {
                return result;
            }

            if (_propertyInfo.PropertyType == typeof(string)
                || _propertyInfo.PropertyType == typeof(DateTime)
                || _propertyInfo.PropertyType == typeof(DateTime?)
                )
            {
                //请注意，.Net8环境中Newtonsoft已经限制日期类型为空字符串，所以暂时放弃日期类型转为空字符串
                return _defaultValue;
            }
            //decimal型转为0
            else if (_propertyInfo.PropertyType == typeof(Nullable<decimal>))
                return 0M;
            //int型转为0
            else if (_propertyInfo.PropertyType == typeof(Nullable<int>))
                return 0;
            //集合转为[]
            else if (_propertyInfo.PropertyType.IsGenericType)
            {
                return new List<Newtonsoft.Json.Linq.JObject>(0);
            }
            //对象转为{}
            else if (_propertyInfo.PropertyType.BaseType == typeof(object))
            {
                if (_propertyInfo.PropertyType != typeof(string) && result == null)
                {
                  return  new Newtonsoft.Json.Linq.JObject();
                }
            }
            return result;

        }
    }

第3/3步：定义转换器

//yyyy-MM-dd日期的格式 
public class DateFormat : JsonConverter
 {
     public string format = "yyyy-MM-dd";

     public DateFormat()
     {
        
     }

     public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
     {
         if (value is DateTime dateTime)
         {
             writer.WriteValue(dateTime.ToString(format));
         }
         else
         {
             writer.WriteNull();
         }
     }

     public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
     {
         if (reader.TokenType == JsonToken.Null)
             return null;

         if (reader.TokenType == JsonToken.String)
         {
             string text = reader.Value.ToString();
             if (DateTime.TryParse(text, out DateTime dateTime))
             {
                 return dateTime;
             }
         }

         throw new Exception($"Cannot convert {reader.TokenType} to {objectType}.");
     }

     public override bool CanConvert(Type objectType)
     {
         return objectType == typeof(DateTime);
     }
 }

//yyyy-MM-dd HH:mm:ss日期的格式
 public class DateTimeFormat : JsonConverter
 {
     public string format = "yyyy-MM-dd HH:mm:ss";

     public DateTimeFormat()
     {

     }

     public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
     {
         if (value is DateTime dateTime)
         {
             writer.WriteValue(dateTime.ToString(format));
         }
         else
         {
             writer.WriteNull();
         }
     }

     public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
     {
         if (reader.TokenType == JsonToken.Null)
             return null;

         if (reader.TokenType == JsonToken.String)
         {
             string text = reader.Value.ToString();
             if (DateTime.TryParse(text, out DateTime dateTime))
             {
                 return dateTime;
             }
         }

         throw new Exception($"Cannot convert {reader.TokenType} to {objectType}.");
     }

     public override bool CanConvert(Type objectType)
     {
         return objectType == typeof(DateTime);
     }
 }



    /// <summary>
    /// 数字类型转为字符串
    /// </summary>
    public sealed class NumberToStrConverter : JsonConverter
    {
        /// <summary>
        /// 转换成字符串的类型
        /// </summary>
        private readonly NumberConverterShip _ship;

        /// <summary>
        /// 大数据json序列化重写实例化
        /// </summary>
        public NumberToStrConverter()
        {
            _ship = (NumberConverterShip)0xFF;
        }

        /// <summary>
        /// 大数据json序列化重写实例化
        /// </summary>
        /// <param name="ship">转换成字符串的类型</param>
        public NumberToStrConverter(NumberConverterShip ship)
        {
            _ship = ship;
        }

        /// <inheritdoc />
        /// <summary>
        /// 确定此实例是否可以转换指定的对象类型。
        /// </summary>
        /// <param name="objectType">对象的类型。</param>
        /// <returns>如果此实例可以转换指定的对象类型，则为：<c>true</c>，否则为：<c>false</c></returns>
        public override bool CanConvert(Type objectType)
        {
            var typecode = Type.GetTypeCode(objectType.Name.Equals("Nullable`1") ? objectType.GetGenericArguments().First() : objectType);
            switch (typecode)
            {
                case TypeCode.Int64:
                    return (_ship & NumberConverterShip.Int64) == NumberConverterShip.Int64;
              //  case TypeCode.Decimal:
                  //  return (_ship & NumberConverterShip.Decimal) == NumberConverterShip.Decimal;
              //  case TypeCode.Double:
                 //   return (_ship & NumberConverterShip.Double) == NumberConverterShip.Double;
               // case TypeCode.UInt64:
                 //   return (_ship & NumberConverterShip.UInt64) == NumberConverterShip.UInt64;
               // case TypeCode.Single:
                 //   return (_ship & NumberConverterShip.Single) == NumberConverterShip.Single;
                default: return false;
            }
        }

        /// <inheritdoc />
        /// <summary>
        /// 读取对象的JSON表示。
        /// </summary>
        /// <param name="reader">从 <see cref="T:Newtonsoft.Json.JsonReader" /> 中读取。</param>
        /// <param name="objectType">对象的类型。</param>
        /// <param name="existingValue">正在读取的对象的现有值。</param>
        /// <param name="serializer">调用的序列化器实例。</param>
        /// <returns>对象值。</returns>
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            if (reader.TokenType == JsonToken.Null)
            {
                return "";
            }

            return AsType(reader.Value.ToString(), objectType);
        }


        /// <summary>
        /// 字符串格式数据转其他类型数据
        /// </summary>
        /// <param name="input">输入的字符串</param>
        /// <param name="destinationType">目标格式</param>
        /// <returns>转换结果</returns>
        public static object AsType(string input, Type destinationType)
        {
            try
            {
                var converter = TypeDescriptor.GetConverter(destinationType);
                if (converter.CanConvertFrom(typeof(string)))
                {
                    return converter.ConvertFrom(null, null, input);
                }

                converter = TypeDescriptor.GetConverter(typeof(string));
                if (converter.CanConvertTo(destinationType))
                {
                    return converter.ConvertTo(null, null, input, destinationType);
                }
            }
            catch
            {
                return null;
            }
            return null;
        }

        /// <inheritdoc />
        /// <summary>
        /// 写入对象的JSON表示形式。
        /// </summary>
        /// <param name="writer">要写入的 <see cref="T:Newtonsoft.Json.JsonWriter" /> 。</param>
        /// <param name="value">要写入对象值</param>
        /// <param name="serializer">调用的序列化器实例。</param>
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            if (value == null)
            {
                writer.WriteNull();
            }
            else
            {
                var objectType = value.GetType();
                var typeCode = Type.GetTypeCode(objectType.Name.Equals("Nullable`1") ? objectType.GetGenericArguments().First() : objectType);
                switch (typeCode)
                {
                    case TypeCode.Int64:
                        writer.WriteValue(((long)value).ToString());
                        break;
                    //case TypeCode.Decimal:
                     //  writer.WriteValue(((decimal)value).ToString("f6"));
                      //  break;
                  //  case TypeCode.Double:
                      //  writer.WriteValue(((double)value).ToString("f4"));
                     //   break;
                   // case TypeCode.Single:
                     //   writer.WriteValue(((float)value).ToString("f2"));
                      //  break;
                   // default:
                      //  writer.WriteValue(value.ToString());
                      // break;
                }
            }
        }

.Net MVC项目使用演示：  

        protected ActionResult Json(object data,string ContentType = "application/json", string formatter= "yyyy-MM-dd HH:mm:ss",bool StringEnumConverter=false) {
            var res= new CustomsJsonResult(data)
            {
                ContentType = ContentType,
                StringEnumConverter = StringEnumConverter,
                formatter = formatter
            };
            return res;
        }

其中的data就是我们要转为json字符串的数据 。