✨ feat(Json): 添加 DateTimeNullTo1900Converter 并实现相关测试

- 新增 DateTimeNullTo1900Converter 类，用于将 DateTime 类型的 null 值转换为 1900-01-01
- 在 JsonHelperTest 中添加多个测试用例，验证 DateTimeNullTo1900Converter 的序列化和反序列化行为
- 确保可空 DateTime 类型在序列化时正确处理 null 值
- 验证 JSON 中的 null 值在反序列化时能够正确还原为 1900-01-01

Author: jianxuanbing

src/Bing.Utils/Json/Converters/DateTimeNullTo1900Converter.cs

@@ -0,0 +1,60 @@
+using Newtonsoft.Json;
+
+namespace Bing.Utils.Json.Converters;
+
+/// <summary>
+/// 日期时间转换器
+/// </summary>
+public class DateTimeNullTo1900Converter : JsonConverter
+{
+    /// <summary>
+    /// 默认日期
+    /// </summary>
+    private static readonly DateTime DefaultDate = new DateTime(1900, 1, 1);
+
+    /// <summary>
+    /// 确定此实例是否可以转换指定的对象类型
+    /// </summary>
+    /// <param name="objectType">对象类型</param>
+    public override bool CanConvert(Type objectType) => objectType == typeof(DateTime) || objectType == typeof(DateTime?);
+
+    /// <summary>
+    /// 写入JSON对象
+    /// </summary>
+    /// <param name="writer">JSON写入器</param>
+    /// <param name="value">对象值</param>
+    /// <param name="serializer">JSON序列化器</param>
+    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+    {
+        var dateTime = value as DateTime?;
+        if (dateTime == null || dateTime.Value == DefaultDate)
+            writer.WriteNull();
+        else
+            writer.WriteValue(dateTime.Value);
+    }
+
+    /// <summary>
+    /// 读取JSON对象
+    /// </summary>
+    /// <param name="reader">JSON读取器</param>
+    /// <param name="objectType">对象类型</param>
+    /// <param name="existingValue">存在值</param>
+    /// <param name="serializer">JSON序列化器</param>
+    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+    {
+        var isNullable = (objectType == typeof(DateTime?));
+        if (reader.TokenType == JsonToken.Null)
+            return isNullable ? (DateTime?)DefaultDate : DefaultDate;
+        if (reader.TokenType == JsonToken.String)
+        {
+            var str = (string)reader.Value;
+            if (string.IsNullOrWhiteSpace(str))
+                return isNullable ? (DateTime?)DefaultDate : DefaultDate;
+            if (DateTime.TryParse(str, out var result))
+                return result;
+        }
+        if (reader.TokenType == JsonToken.Date && reader.Value is DateTime dt)
+            return dt;
+        return isNullable ? (DateTime?)DefaultDate : DefaultDate;
+    }
+}

tests/Bing.Utils.Tests/Json/JsonHelperTest.cs

@@ -1,6 +1,7 @@
 using Bing.Tests.Samples.Json;
 using Bing.Tests.XUnitHelpers;
 using Bing.Utils.Json;
+using Bing.Utils.Json.Converters;
 using Newtonsoft.Json;
 
 namespace Bing.Utils.Tests.Json;
@@ -10,6 +11,8 @@ namespace Bing.Utils.Tests.Json;
 /// </summary>
 public class JsonHelperTest : TestBase
 {
+    private static readonly DateTime DefaultDate = new(1900, 1, 1);
+
     /// <summary>
     /// 初始化一个<see cref="TestBase"/>类型的实例
     /// </summary>
@@ -91,4 +94,145 @@ public void Test_ToObject()
         var customer = JsonHelper.ToObject<JsonTestSample>("{\"Name\":\"a\"}");
         Assert.Equal("a", customer.Name);
     }
+
+    /// <summary>
+    /// 测试 - 确保 DateTime 等于 1900-01-01 时，序列化结果为 null
+    /// </summary>
+    [Fact]
+    public void Serialize_1900DateTime_ShouldBeNull()
+    {
+        var sample = new JsonDateTimeSample
+        {
+            ConfirmTime = DefaultDate,
+            OptionalTime = DefaultDate
+        };
+
+        var json = JsonConvert.SerializeObject(sample);
+        Output.WriteLine(json);
+        Assert.Contains("\"ConfirmTime\":null", json);
+        Assert.Contains("\"OptionalTime\":null", json);
+    }
+
+    /// <summary>
+    /// 测试 - 可空时间字段为 null 时，序列化结果应为 null；非 1900 日期应正常序列化
+    /// </summary>
+    [Fact]
+    public void Serialize_NullOptionalTime_ShouldBeNull()
+    {
+        var sample = new JsonDateTimeSample
+        {
+            ConfirmTime = new DateTime(2025,1,1),
+            OptionalTime = null
+        };
+
+        var json = JsonConvert.SerializeObject(sample);
+        Output.WriteLine(json);
+        Assert.Contains("\"OptionalTime\":null", json);
+        Assert.Contains("\"ConfirmTime\":\"2025-01-01T00:00:00\"", json);
+    }
+
+    /// <summary>
+    /// 测试 - JSON 中为 null 的时间字段，反序列化应还原为 1900-01-01
+    /// </summary>
+    [Fact]
+    public void Deserialize_NullJson_ShouldReturnDefaultDate()
+    {
+        var json = "{\"ConfirmTime\":null,\"OptionalTime\":null}";
+        var sample = JsonConvert.DeserializeObject<JsonDateTimeSample>(json);
+        Output.WriteLine(json);
+        Assert.Equal(DefaultDate, sample.ConfirmTime);
+        Assert.Equal(DefaultDate, sample.OptionalTime);
+    }
+
+    /// <summary>
+    /// 测试 - JSON 中为正常日期字符串时，能够正确反序列化为 DateTime 对象
+    /// </summary>
+    [Fact]
+    public void Deserialize_NormalDate_ShouldParseCorrectly()
+    {
+        var json = "{\"ConfirmTime\":\"2023-12-12 10:30:00\",\"OptionalTime\":\"2023-12-12 10:30:00\"}";
+
+        var dto = JsonConvert.DeserializeObject<JsonDateTimeSample>(json);
+
+        var expected = new DateTime(2023, 12, 12, 10, 30, 0);
+        Output.WriteLine(json);
+        Assert.Equal(expected, dto.ConfirmTime);
+        Assert.Equal(expected, dto.OptionalTime);
+    }
+
+    /// <summary>
+    /// 测试 - JSON 中为正常日期字符串时，能够正确反序列化为 DateTime 对象
+    /// </summary>
+    [Fact]
+    public void Deserialize_NormalDate_ShouldParseCorrectly_1()
+    {
+        var json = "{\"ConfirmTime\":\"2023-12-12T10:30:00\",\"OptionalTime\":\"2023-12-12T10:30:00\"}";
+
+        var dto = JsonConvert.DeserializeObject<JsonDateTimeSample>(json);
+
+        var expected = new DateTime(2023, 12, 12, 10, 30, 0);
+        Output.WriteLine(json);
+        Assert.Equal(expected, dto.ConfirmTime);
+        Assert.Equal(expected, dto.OptionalTime);
+    }
+
+    /// <summary>
+    /// 测试 - JSON 中为正常日期字符串时，能够正确反序列化为 DateTime 对象
+    /// </summary>
+    [Fact]
+    public void Deserialize_NormalDate_ShouldParseCorrectly_2()
+    {
+        var json = "{\"ConfirmTime\":\"2023-12-12T10:30:00\",\"OptionalTime\":\"1900-01-01T00:00:00\"}";
+
+        var dto = JsonConvert.DeserializeObject<JsonDateTimeSample>(json);
+
+        var expected = new DateTime(2023, 12, 12, 10, 30, 0);
+        Output.WriteLine(json);
+        Assert.Equal(expected, dto.ConfirmTime);
+        Assert.Equal(DefaultDate, dto.OptionalTime);
+    }
+
+    /// <summary>
+    /// 测试 - JSON 中为正常日期字符串时，能够正确反序列化为 DateTime 对象
+    /// </summary>
+    [Fact]
+    public void Deserialize_NormalDate_ShouldParseCorrectly_3()
+    {
+        var json = "{\"ConfirmTime\":\"2023-12-12T10:30:00\",\"OptionalTime\":null}";
+
+        var dto = JsonConvert.DeserializeObject<JsonDateTimeSample>(json);
+
+        var expected = new DateTime(2023, 12, 12, 10, 30, 0);
+        Output.WriteLine(json);
+        Assert.Equal(expected, dto.ConfirmTime);
+        Assert.Equal(DefaultDate, dto.OptionalTime);
+    }
+
+    /// <summary>
+    /// 测试 - 1900-01-01 的时间序列化为 null 后反序列化应还原为 1900-01-01
+    /// </summary>
+    [Fact]
+    public void RoundTrip_Serialization_Deserialization_ShouldMaintainSemantics()
+    {
+        var original = new JsonDateTimeSample
+        {
+            ConfirmTime = DefaultDate,
+            OptionalTime = null
+        };
+
+        var json = JsonConvert.SerializeObject(original);
+        var deserialized = JsonConvert.DeserializeObject<JsonDateTimeSample>(json);
+        Output.WriteLine(json);
+        Assert.Equal(DefaultDate, deserialized.ConfirmTime);
+        Assert.Equal(DefaultDate, deserialized.OptionalTime);
+    }
+
+    private class JsonDateTimeSample
+    {
+        [JsonConverter(typeof(DateTimeNullTo1900Converter))]
+        public DateTime ConfirmTime { get; set; }
+
+        [JsonConverter(typeof(DateTimeNullTo1900Converter))]
+        public DateTime? OptionalTime { get; set; }
+    }
 }