dotnet/Library/Vit/Vit.Core/Test/Vit.Core.Module.Serialization.Qps/Program.cs

@@ -56,29 +56,44 @@ namespace App
 
                 // 4线程 87万(cpu 52%)
                 // 8线程 103万(cpu 95%)
-                // var Instance = Vit.Core.Module.Serialization.Serialization_Text.Instance;
+                var Instance = Vit.Core.Module.Serialization.Serialization_Text.Instance;
 
                 // 4线程 200万(cpu 50%)
-                var Instance = Vit.Core.Module.Serialization.Serialization_MessagePack.Instance;
+                // var Instance = Vit.Core.Module.Serialization.Serialization_MessagePack.Instance;
 
                 while (true)
                 {
                     try
                     {
+                        byte[] bytes;
+                        JObject jo;
+                        string str;
+                        RpcContextData data, data2;
+
                         for (var t = 0; t < 10000; t++)
                         {
-                            var data = new RpcContextData { route = "/a" };
+                            data = new RpcContextData { route = "/a" };
                             data.http.method = "GET";
 
-                            data.user = new JObject() { ["userInfo"] = "dd" };
-                            data.joUser = new JObject() { ["userInfo"] = "jo", ["age"] = 12, ["n"] = null, ["obj"] = new JArray { 1,true,12.5,DateTime.Now } };
+                            bytes = Instance.SerializeToBytes(data);
+                            data2 = Instance.DeserializeFromBytes<RpcContextData>(bytes);
+
+
+
+                            data = new RpcContextData { route = "/a" };
+                            jo = new JObject() { ["userInfo11"] = 11.545, ["userInfo12"] = 123456789012456 };
+                            jo["userInfo13"] = new JObject() { ["userInfo131"] = "131", ["userInfo132"] = "132" };
+                            jo["userInfo14"] = null;
+                            jo["userInfo15"] = new JArray { 1, true, 12.5, null, DateTime.Now };
+
+                            data.user = jo;
+                            data.joUser = jo;
 
-                            var str = Instance.SerializeToString(data);
+                            str = Instance.SerializeToString(data);
 
-                            var bytes = Instance.SerializeToBytes(data);
- 
+                            bytes = Instance.SerializeToBytes(data);
 
-                            var data2 = Instance.DeserializeFromBytes<RpcContextData>(bytes);
+                            data2 = Instance.DeserializeFromBytes<RpcContextData>(bytes);
                         }
 
                         qpsInfo.RequestCount++;

dotnet/Library/Vit/Vit.Core/Vit.Core/Module/Serialization/Serialization_MessagePack.cs

@@ -3,7 +3,6 @@ using System.Runtime.CompilerServices;
 using MessagePack;
 using MessagePack.Formatters;
 using MessagePack.Resolvers;
-using Newtonsoft.Json.Linq;
 using Vit.Extensions;
 
 namespace Vit.Core.Module.Serialization
@@ -18,7 +17,7 @@ namespace Vit.Core.Module.Serialization
 
 
 
-        protected MessagePackSerializerOptions options;
+        public readonly MessagePackSerializerOptions options;
         public Serialization_MessagePack()
         {
  
@@ -26,8 +25,8 @@ namespace Vit.Core.Module.Serialization
                 new IMessagePackFormatter[]
                 {  
 
-                    NewtonsoftFormatter_JObject.Instance,
-                    NewtonsoftFormatter_JArray.Instance,
+                    MessagePackFormatter_JObject.Instance,
+                    MessagePackFormatter_JArray.Instance,
 
                     //NilFormatter.Instance,
                     //new IgnoreFormatter<MethodBase>(),
@@ -166,298 +165,303 @@ namespace Vit.Core.Module.Serialization
 
 
 
+ 
 
-        #region NewtonsoftFormatter_SaveAsString
-        private class NewtonsoftFormatter_SaveAsString<NewtonsoftType> : IMessagePackFormatter<NewtonsoftType>
-            //where NewtonsoftType: Newtonsoft.Json.Linq.JToken
-        {
-            public void Serialize(
-              ref MessagePackWriter writer, NewtonsoftType value, MessagePackSerializerOptions options)
-            {
-                if (value == null)
-                {
-                    writer.WriteNil();
-                    return;
-                }
+    }
+}
 
-                var str = Serialization_Newtonsoft.Instance.SerializeToString(value);
-                writer.Write(str);
-            }
 
-            public NewtonsoftType Deserialize(
-              ref MessagePackReader reader, MessagePackSerializerOptions options)
-            {
-                if (reader.TryReadNil())
-                {
-                    return default;
-                }
 
-                options.Security.DepthStep(ref reader);
 
-                var data = reader.ReadString();
+#region 适配 Newtonsoft
+
+namespace Vit.Core.Module.Serialization
+{
+    using Newtonsoft.Json.Linq;
 
-                reader.Depth--;
 
-                return Newtonsoft.Json.JsonConvert.DeserializeObject<NewtonsoftType>(data);        
-            }
-        }
 
 
-        #endregion
 
+    #region MessagePackFormatter JObject JArray 
 
-        #region NewtonsoftFormatter JObject JArray 
 
+    class MessagePackFormatter_JObject : IMessagePackFormatter<Newtonsoft.Json.Linq.JObject>
+    {
+
+        public static readonly MessagePackFormatter_JObject Instance = new MessagePackFormatter_JObject();
 
-        private class NewtonsoftFormatter_JObject  : IMessagePackFormatter<Newtonsoft.Json.Linq.JObject>         
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Serialize(
+          ref MessagePackWriter writer, Newtonsoft.Json.Linq.JObject value, MessagePackSerializerOptions options)
         {
+            if (value.IsNull())
+            {
+                writer.WriteNil();
+                return;
+            }
 
-            public static readonly NewtonsoftFormatter_JObject Instance = new NewtonsoftFormatter_JObject();
+            writer.WriteMapHeader(value.Count);
 
-            public void Serialize(
-              ref MessagePackWriter writer, Newtonsoft.Json.Linq.JObject value, MessagePackSerializerOptions options)
+            foreach (var kv in value)
             {
-                if (value == null)
+                //key
+                writer.Write(kv.Key);
+
+
+                //value
+                if (kv.Value.IsNull())
                 {
                     writer.WriteNil();
-                    return;
+                    continue;
                 }
 
+                switch (kv.Value)
+                {
+                    case JObject jo:
+                        //if (objectFormatter == null) objectFormatter = options.Resolver.GetFormatterWithVerify<JObject>();
+                        //objectFormatter?.Serialize(ref writer, jo, options); 
+                        Serialize(ref writer, jo, options);
+                        break;
+                    case JArray ja:
+                        //if (arrayFormatter == null) arrayFormatter = options.Resolver.GetFormatterWithVerify<JArray>();
+                        //arrayFormatter?.Serialize(ref writer, ja, options);
+                        MessagePackFormatter_JArray.Instance.Serialize(ref writer, ja, options);
+                        break;
+
+                    case JValue jv:
+                        switch (jv.Type)
+                        {
+                            case JTokenType.String: writer.Write(jv.Value<string>()); break;
+                            case JTokenType.Integer: writer.Write(jv.Value<long>()); break;
+                            case JTokenType.Float: writer.Write(jv.Value<double>()); break;
+                            case JTokenType.Boolean: writer.Write(jv.Value<bool>()); break;
+                            case JTokenType.Date: writer.Write(jv.Value<DateTime>().ToString("yyyy-MM-dd HH:mm:ss")); break;
+                            default: writer.Write(Serialization_Newtonsoft.Instance.SerializeToString(jv)); break;
+                        }
+                        break;
+                    default:
+                        string str = Serialization_Newtonsoft.Instance.SerializeToString(kv.Value);
+                        writer.Write(str);
+                        break;
+                }
+            }
+        }
+
+
 
-                writer.WriteMapHeader(value.Count);
-             
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Newtonsoft.Json.Linq.JObject Deserialize(
+          ref MessagePackReader reader, MessagePackSerializerOptions options)
+        {
+            if (reader.TryReadNil())
+            {
+                return default;
+            }
 
-                //IMessagePackFormatter<JObject> objectFormatter = null;
-                //IMessagePackFormatter<JArray> arrayFormatter = null;
+            var result = new JObject();
+            int count = reader.ReadMapHeader();
+            if (count == 0) return result;
 
-                foreach (var kv in value) 
+            options.Security.DepthStep(ref reader);
+            try
+            {
+                for (int i = 0; i < count; i++)
                 {
-                    //key
-                    writer.Write(kv.Key);
-             
+                    string key = reader.ReadString();
 
-                    //value
-                    if (kv.Value.IsNull()) 
+                    switch (reader.NextMessagePackType)
                     {
-                        writer.WriteNil();
-                        continue;
-                    }
+                        case MessagePackType.Map:                
+                            result[key] = Deserialize(ref reader, options);
 
-                    switch (kv.Value)
-                    {                        
-                        case JObject jo:
-                            //if (objectFormatter == null) objectFormatter = options.Resolver.GetFormatterWithVerify<JObject>();
-                            //objectFormatter?.Serialize(ref writer, jo, options); 
-                            Serialize(ref writer, jo, options);
                             break;
-                        case JArray ja:
-                            //if (arrayFormatter == null) arrayFormatter = options.Resolver.GetFormatterWithVerify<JArray>();
-                            //arrayFormatter?.Serialize(ref writer, ja, options);
-                            NewtonsoftFormatter_JArray.Instance.Serialize(ref writer, ja, options);
+                        case MessagePackType.Array:                  
+                            result[key] = MessagePackFormatter_JArray.Instance.Deserialize(ref reader, options);
                             break;
-                     
-                        case JValue jv:
-                            switch (jv.Type) 
-                            {
-                                case JTokenType.String: writer.Write(jv.Value<string>()); break;
-                                case JTokenType.Integer: writer.Write(jv.Value<long>()); break;
-                                case JTokenType.Float: writer.Write(jv.Value<double>()); break;
-                                case JTokenType.Boolean: writer.Write(jv.Value<bool>()); break;
-                                case JTokenType.Date: writer.Write(jv.Value<DateTime>().ToString("yyyy-MM-dd HH:mm:ss")); break;
-                                default: writer.Write(Serialization_Newtonsoft.Instance.SerializeToString(jv)); break;
-                            }
+                        case MessagePackType.Integer: result[key] = reader.ReadInt64(); break;
+                        case MessagePackType.Boolean: result[key] = reader.ReadBoolean(); break;
+                        case MessagePackType.Float: result[key] = reader.ReadDouble(); break;
+                        case MessagePackType.String: result[key] = reader.ReadString(); break;
+                        case MessagePackType.Nil:
+                            result[key] = null;
+                            reader.Skip();
                             break;
                         default:
-                            string str = Serialization_Newtonsoft.Instance.SerializeToString(kv.Value);
-                            writer.Write(str); 
+                            result[key] = null;
+                            reader.Skip();
                             break;
                     }
-                } 
-            }
 
-            public Newtonsoft.Json.Linq.JObject Deserialize(
-              ref MessagePackReader reader, MessagePackSerializerOptions options)
-            {
-                if (reader.TryReadNil())
-                {
-                    return default;
                 }
+            }
+            finally
+            {
+                reader.Depth--;
+            }
 
-                var result = new JObject();
-                int count = reader.ReadMapHeader();
-                if (count == 0) return result;
-
-                options.Security.DepthStep(ref reader);
-                try
-                {
-                    //IMessagePackFormatter<JObject> objectFormatter = null;
-                    //IMessagePackFormatter<JArray> arrayFormatter = null;
-
-                    for (int i = 0; i < count; i++)
-                    {
-                        string key = reader.ReadString();
-
-                        switch (reader.NextMessagePackType)
-                        {
-                            case MessagePackType.Map:
-                                //if (objectFormatter == null) objectFormatter = options.Resolver.GetFormatterWithVerify<JObject>();
-                                //result[key] = objectFormatter?.Deserialize(ref reader, options);
-                                result[key] = Deserialize(ref reader, options);
-
-                                break;
-                            case MessagePackType.Array:
-                                //if (arrayFormatter == null) arrayFormatter = options.Resolver.GetFormatterWithVerify<JArray>();
-                                //result[key] = arrayFormatter?.Deserialize(ref reader, options);
-                                result[key] = NewtonsoftFormatter_JArray.Instance.Deserialize(ref reader, options);
-                                break;
-                            case MessagePackType.Integer: result[key] = reader.ReadInt64(); break;
-                            case MessagePackType.Boolean: result[key] = reader.ReadBoolean(); break;
-                            case MessagePackType.Float: result[key] = reader.ReadDouble(); break;
-                            case MessagePackType.String: result[key] = reader.ReadString(); break;
-                            case MessagePackType.Nil:
-                                result[key] = null;
-                                reader.Skip();
-                                break;
-                            default:
-                                result[key] = null;
-                                reader.Skip();
-                                break;
-                        }
+            return result;
+        }
+    }
 
-                    }
-                }
-                finally
-                {
-                    reader.Depth--;
-                }
+    class MessagePackFormatter_JArray : IMessagePackFormatter<JArray>
+    {
+        public static readonly MessagePackFormatter_JArray Instance = new MessagePackFormatter_JArray();
 
 
-                return result;
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Serialize(
+          ref MessagePackWriter writer, Newtonsoft.Json.Linq.JArray value, MessagePackSerializerOptions options)
+        {
+            if (value.IsNull())
+            {
+                writer.WriteNil();
+                return;
             }
-        }
 
-        private class NewtonsoftFormatter_JArray : IMessagePackFormatter<Newtonsoft.Json.Linq.JArray>
-        {
-            public static readonly NewtonsoftFormatter_JArray Instance = new NewtonsoftFormatter_JArray();
 
+            writer.WriteArrayHeader(value.Count);
 
-            public void Serialize(
-              ref MessagePackWriter writer, Newtonsoft.Json.Linq.JArray value, MessagePackSerializerOptions options)
+            foreach (var token in value)
             {
-                if (value == null)
+                if (token.IsNull())
                 {
                     writer.WriteNil();
-                    return;
+                    continue;
+                }
+                switch (token)
+                {
+                    case JObject jo:                      
+                        MessagePackFormatter_JObject.Instance.Serialize(ref writer, jo, options);
+                        break;
+                    case JArray ja:                     
+                        Serialize(ref writer, ja, options);
+                        break;
+                    case JValue jv:
+                        switch (jv.Type)
+                        {
+                            case JTokenType.String: writer.Write(jv.Value<string>()); break;
+                            case JTokenType.Integer: writer.Write(jv.Value<long>()); break;
+                            case JTokenType.Float: writer.Write(jv.Value<double>()); break;
+                            case JTokenType.Boolean: writer.Write(jv.Value<bool>()); break;
+                            case JTokenType.Date: writer.Write(jv.Value<DateTime>().ToString("yyyy-MM-dd HH:mm:ss")); break;
+                            default: writer.Write(Serialization_Newtonsoft.Instance.SerializeToString(jv)); break;
+                        }
+                        break;
+                    default:
+                        string str = Serialization_Newtonsoft.Instance.SerializeToString(token);
+                        writer.Write(str);
+                        break;
                 }
 
+            }
+        }
+
 
-                writer.WriteArrayHeader(value.Count);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Newtonsoft.Json.Linq.JArray Deserialize(
+          ref MessagePackReader reader, MessagePackSerializerOptions options)
+        {
+            if (reader.TryReadNil())
+            {
+                return default;
+            }
 
+            var result = new JArray();
+            int count = reader.ReadArrayHeader();
+            if (count == 0) return result;
 
-                //IMessagePackFormatter<JObject> objectFormatter = null;
-                //IMessagePackFormatter<JArray> arrayFormatter = null;
+            options.Security.DepthStep(ref reader);
+            try
+            {       
 
-                foreach (var token in value)
+                for (int i = 0; i < count; i++)
                 {
-                    if (token.IsNull()) 
-                    {
-                        writer.WriteNil();
-                        continue;
-                    }
-                    switch (token)
+
+                    switch (reader.NextMessagePackType)
                     {
-                        case JObject jo:
-                            //if (objectFormatter == null) objectFormatter = options.Resolver.GetFormatterWithVerify<JObject>();
-                            //objectFormatter?.Serialize(ref writer, jo, options);
-                            NewtonsoftFormatter_JObject.Instance.Serialize(ref writer, jo, options);
+                        case MessagePackType.Map:                          
+                            result.Add(MessagePackFormatter_JObject.Instance.Deserialize(ref reader, options));
                             break;
-                        case JArray ja:
-                            //if (arrayFormatter == null) arrayFormatter = options.Resolver.GetFormatterWithVerify<JArray>();
-                            //arrayFormatter?.Serialize(ref writer, ja, options);
-                            Serialize(ref writer, ja, options);
+                        case MessagePackType.Array:                           
+                            result.Add(Deserialize(ref reader, options));
+                            break;
+                        case MessagePackType.Integer: result.Add(reader.ReadInt64()); break;
+                        case MessagePackType.Boolean: result.Add(reader.ReadBoolean()); break;
+                        case MessagePackType.Float: result.Add(reader.ReadDouble()); break;
+                        case MessagePackType.String: result.Add(reader.ReadString()); break;
+                        case MessagePackType.Nil:
+                            result.Add(null);
+                            reader.Skip();
                             break;
-                        case JValue jv:
-                            switch (jv.Type)
-                            {
-                                case JTokenType.String: writer.Write(jv.Value<string>()); break;
-                                case JTokenType.Integer: writer.Write(jv.Value<long>()); break;
-                                case JTokenType.Float: writer.Write(jv.Value<double>()); break;
-                                case JTokenType.Boolean: writer.Write(jv.Value<bool>()); break;
-                                case JTokenType.Date: writer.Write(jv.Value<DateTime>().ToString("yyyy-MM-dd HH:mm:ss")); break;
-                                default: writer.Write(Serialization_Newtonsoft.Instance.SerializeToString(jv)); break;
-                            }
-                           break;
                         default:
-                            string str = Serialization_Newtonsoft.Instance.SerializeToString(token);
-                            writer.Write(str);
+                            result.Add(null);
+                            reader.Skip();
                             break;
                     }
 
                 }
             }
-
-            public Newtonsoft.Json.Linq.JArray Deserialize(
-              ref MessagePackReader reader, MessagePackSerializerOptions options)
+            finally
             {
-                if (reader.TryReadNil())
-                {
-                    return default;
-                }
+                reader.Depth--;
+            }
 
-                var result = new JArray();
-                int count = reader.ReadArrayHeader();
-                if (count == 0) return result;
 
-                options.Security.DepthStep(ref reader);
-                try
-                {
-                    //IMessagePackFormatter<JObject> objectFormatter = null;
-                    //IMessagePackFormatter<JArray> arrayFormatter = null;
+            return result;
+        }
+    }
+
+    #endregion
+
 
-                    for (int i = 0; i < count; i++)
-                    {                      
 
-                        switch (reader.NextMessagePackType)
-                        {
-                            case MessagePackType.Map:
-                                //if (objectFormatter == null) objectFormatter = options.Resolver.GetFormatterWithVerify<JObject>();
-                                //result.Add( objectFormatter?.Deserialize(ref reader, options));
-                                result.Add(NewtonsoftFormatter_JObject.Instance.Deserialize(ref reader, options));
-                                break;
-                            case MessagePackType.Array:
-                                //if (arrayFormatter == null) arrayFormatter = options.Resolver.GetFormatterWithVerify<JArray>();
-                                //result.Add(arrayFormatter?.Deserialize(ref reader, options));
-                                result.Add(Deserialize(ref reader, options));
-                                break;
-                            case MessagePackType.Integer: result.Add(reader.ReadInt64()); break;
-                            case MessagePackType.Boolean: result.Add(reader.ReadBoolean()); break;
-                            case MessagePackType.Float: result.Add(reader.ReadDouble()); break;
-                            case MessagePackType.String: result.Add(reader.ReadString()); break;
-                            case MessagePackType.Nil:
-                                result.Add(null);
-                                reader.Skip();
-                                break;
-                            default:
-                                result.Add(null);
-                                reader.Skip();
-                                break;
-                        }
 
-                    }
-                }
-                finally
-                {
-                    reader.Depth--;
-                }
 
 
-                return result;
+
+
+
+    #region MessagePackFormatter_NewtonsoftAsString
+    class MessagePackFormatter_NewtonsoftAsString<NewtonsoftType> : IMessagePackFormatter<NewtonsoftType>
+    //where NewtonsoftType: Newtonsoft.Json.Linq.JToken
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Serialize(
+          ref MessagePackWriter writer, NewtonsoftType value, MessagePackSerializerOptions options)
+        {
+            if (value == null)
+            {
+                writer.WriteNil();
+                return;
             }
+
+            var str = Serialization_Newtonsoft.Instance.SerializeToString(value);
+            writer.Write(str);
         }
 
-        #endregion
 
- 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public NewtonsoftType Deserialize(
+          ref MessagePackReader reader, MessagePackSerializerOptions options)
+        {
+            if (reader.TryReadNil())
+            {
+                return default;
+            }
 
+            options.Security.DepthStep(ref reader);
+
+            var data = reader.ReadString();
+
+            reader.Depth--;
+
+            return Newtonsoft.Json.JsonConvert.DeserializeObject<NewtonsoftType>(data);
+        }
     }
+
+
+    #endregion
 }
+
+#endregion

dotnet/Library/Vit/Vit.Core/Vit.Core/Module/Serialization/Serialization_Text.cs

@@ -1,26 +1,82 @@
 using System;
 using System.Runtime.CompilerServices;
 using System.Text.Json;
+using System.Text.Json.Serialization;
+
+using Vit.Core.Util.ConfigurationManager;
 
 namespace Vit.Core.Module.Serialization
 {
+    /// <summary>
+    ///  https://github.com/dotnet/runtime/tree/main/src/libraries/System.Text.Json
+    ///  
+    /// System.Text.Json 自定义Converter实现时间转换 https://my.oschina.net/u/4359742/blog/3314243
+    /// </summary>
     public class Serialization_Text : ISerialization
     {
 
         public static readonly Serialization_Text Instance = new Serialization_Text();
 
 
-        public JsonSerializerOptions serializeOptions = new JsonSerializerOptions
+
+
+
+
+
+        public readonly JsonSerializerOptions options = new JsonSerializerOptions
         {
             IncludeFields = true,
             DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull
         };
 
-        public JsonSerializerOptions deserializeOptions = new JsonSerializerOptions
+
+
+        public readonly JsonConverter_DateTime jsonConverter_DateTime = new Serialization_Text.JsonConverter_DateTime();
+
+        public Serialization_Text()
         {
-            IncludeFields = true,
-            DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull
-        };
+            options.Converters.Add(jsonConverter_DateTime);
+            options.Converters.Add(JsonConverter_JObject.Instance);
+            options.Converters.Add(JsonConverter_JArray.Instance);
+
+
+            //日期格式化
+            var DateTimeFormat = ConfigurationManager.Instance.GetByPath<string>("Vit.Serialization.DateTimeFormat")
+                ?? "yyyy-MM-dd HH:mm:ss";
+            jsonConverter_DateTime.DateTimeFormat = DateTimeFormat;
+
+        }
+
+        #region JsonConverter
+        public class JsonConverter_DateTime : JsonConverter<DateTime>
+        {
+            public string DateTimeFormat;
+
+            public JsonConverter_DateTime(string dateFormatString = "yyyy-MM-dd HH:mm:ss")
+            {
+                DateTimeFormat = dateFormatString;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+            {
+                return DateTime.Parse(reader.GetString());
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public override void Write(Utf8JsonWriter writer, DateTime value, JsonSerializerOptions options)
+            {
+                writer.WriteStringValue(value.ToString(DateTimeFormat));
+            }
+        }
+        #endregion
+
+
+
+
+
+
+
 
 
         #region (x.1)object <--> String
@@ -29,16 +85,16 @@ namespace Vit.Core.Module.Serialization
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public string SerializeToString<T>(T value)
-        {  
-            return JsonSerializer.Serialize(value, serializeOptions);
+        {
+            return JsonSerializer.Serialize(value, options);
         }
 
 
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public string SerializeToString(object value,Type type)
+        public string SerializeToString(object value, Type type)
         {
-            return JsonSerializer.Serialize(value, type, serializeOptions);
+            return JsonSerializer.Serialize(value, type, options);
         }
 
         #endregion
@@ -56,8 +112,8 @@ namespace Vit.Core.Module.Serialization
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public object DeserializeFromString(string value, Type type)
-        {  
-            return JsonSerializer.Deserialize(value, type, deserializeOptions);
+        {
+            return JsonSerializer.Deserialize(value, type, options);
         }
 
         #endregion
@@ -72,17 +128,17 @@ namespace Vit.Core.Module.Serialization
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public byte[] SerializeToBytes<T>(T value)
-        {           
+        {
 
-            return JsonSerializer.SerializeToUtf8Bytes(value, serializeOptions); 
+            return JsonSerializer.SerializeToUtf8Bytes(value, options);
         }
 
 
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public byte[] SerializeToBytes(object value,Type type)
+        public byte[] SerializeToBytes(object value, Type type)
         {
-            return JsonSerializer.SerializeToUtf8Bytes(value,type, serializeOptions);
+            return JsonSerializer.SerializeToUtf8Bytes(value, type, options);
         }
         #endregion
 
@@ -91,14 +147,14 @@ namespace Vit.Core.Module.Serialization
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public T DeserializeFromBytes<T>(byte[] bytes)
-        {          
-            return JsonSerializer.Deserialize<T>(bytes, deserializeOptions);
+        {
+            return JsonSerializer.Deserialize<T>(bytes, options);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public object DeserializeFromBytes(byte[] bytes, Type type)
         {
-            return JsonSerializer.Deserialize(bytes, type, deserializeOptions);
+            return JsonSerializer.Deserialize(bytes, type, options);
         }
         #endregion
 
@@ -113,14 +169,14 @@ namespace Vit.Core.Module.Serialization
         public T DeserializeFromSpan<T>(ReadOnlySpan<byte> bytes)
         {
             if (bytes.Length == 0) return default;
-            return JsonSerializer.Deserialize<T>(bytes, deserializeOptions);
+            return JsonSerializer.Deserialize<T>(bytes, options);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public object DeserializeFromSpan(ReadOnlySpan<byte> bytes, Type type)
         {
             if (bytes.Length == 0) return default;
-            return JsonSerializer.Deserialize(bytes, type, deserializeOptions);
+            return JsonSerializer.Deserialize(bytes, type, options);
         }
         #endregion
 
@@ -141,4 +197,308 @@ namespace Vit.Core.Module.Serialization
         #endregion
 
     }
+
 }
+
+
+
+#region 适配 Newtonsoft
+
+namespace Vit.Core.Module.Serialization
+{
+   
+    using Newtonsoft.Json.Linq;
+    using Vit.Extensions;
+
+
+
+    #region JsonConverter_JObject
+    class JsonConverter_JObject : JsonConverter<JObject>
+    {
+        public static readonly JsonConverter_JObject Instance = new JsonConverter_JObject();
+
+
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override void Write(Utf8JsonWriter writer, JObject value, JsonSerializerOptions options)
+        {
+            if (value.IsNull())
+            {
+                writer.WriteNullValue();
+                return;
+            }
+
+
+            writer.WriteStartObject();
+
+            foreach (var kv in value)
+            {
+                if (kv.Value.IsNull())
+                {
+                    continue;
+                }
+
+
+                writer.WritePropertyName(kv.Key);
+
+                switch (kv.Value)
+                {
+                    case JObject jo:                      
+                        Write(writer, jo, options);
+                        break;
+                    case JArray ja:                      
+                        JsonConverter_JArray.Instance.Write(writer, ja, options);
+                        break;
+
+                    case JValue jv:
+                        switch (jv.Type)
+                        {
+                            case JTokenType.String: writer.WriteStringValue(jv.Value<string>()); break;
+                            case JTokenType.Integer: writer.WriteNumberValue(jv.Value<long>()); break;
+                            case JTokenType.Float: writer.WriteNumberValue(jv.Value<double>()); break;
+                            case JTokenType.Boolean: writer.WriteBooleanValue(jv.Value<bool>()); break;
+                            case JTokenType.Date: writer.WriteStringValue(jv.Value<DateTime>().ToString("yyyy-MM-dd HH:mm:ss")); break;
+
+                            default: writer.WriteStringValue(Serialization_Newtonsoft.Instance.SerializeToString(jv)); break;
+                        }
+                        break;
+                    default:
+                        string str = Serialization_Newtonsoft.Instance.SerializeToString(kv.Value);
+                        writer.WriteStringValue(str);
+                        break;
+                }
+            }
+
+
+            writer.WriteEndObject();
+
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override JObject Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            if (reader.TokenType != JsonTokenType.StartObject) return null;
+           
+
+            var result = new JObject();
+
+            while (true)
+            {
+                if (!reader.Read())
+                {
+                    throw new ArgumentException("json read error");
+                }
+
+                if (reader.TokenType == JsonTokenType.EndObject)
+                {
+                    reader.Skip();
+                    break;
+                }
+
+                if (reader.TokenType != JsonTokenType.PropertyName)
+                {
+                    throw new ArgumentException("json read error");
+                }
+
+                string key = reader.GetString();
+
+                if (!reader.Read())
+                {
+                    throw new ArgumentException("json read error");
+                }
+
+
+                switch (reader.TokenType)
+                {
+                    case JsonTokenType.StartObject:
+                        result[key] = Read(ref reader, typeof(JObject), options);
+                        break;
+                    case JsonTokenType.StartArray:
+                        result[key] = JsonConverter_JArray.Instance.Read(ref reader, typeof(JArray), options);
+                        break;
+                    case JsonTokenType.String: result[key] = reader.GetString(); break;
+                    case JsonTokenType.Number:
+                        if (reader.TryGetInt32(out var int32))
+                        {
+                            result[key] = int32;
+                            break;
+                        }
+                        if (reader.TryGetInt64(out var int64))
+                        {
+                            result[key] = int64;
+                            break;
+                        }
+                        if (reader.TryGetDouble(out var d))
+                        {
+                            result[key] = d;
+                            break;
+                        }
+
+                        if (reader.TryGetSingle(out var sing))
+                        {
+                            result[key] = sing;
+                            break;
+                        }
+                        if (reader.TryGetDecimal(out var dec))
+                        {
+                            result[key] = dec;
+                            break;
+                        }
+                        break;
+                    case JsonTokenType.False: result[key] = false; break;
+                    case JsonTokenType.True: result[key] = true; break;
+                        //case JsonTokenType.Null: break;
+                        //case JsonTokenType.None: break;
+                        //default: break;
+                }
+            }
+
+            return result;
+
+        }
+
+
+    }
+    #endregion
+
+
+    #region JsonConverter_JArray
+    class JsonConverter_JArray : JsonConverter<JArray>
+    {
+        public static readonly JsonConverter_JArray Instance = new JsonConverter_JArray();
+
+
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override void Write(Utf8JsonWriter writer, JArray value, JsonSerializerOptions options)
+        {
+            if (value.IsNull())
+            {
+                writer.WriteNullValue();
+                return;
+            }
+
+
+            writer.WriteStartArray();
+
+            foreach (var token in value)
+            {
+                if (token.IsNull())
+                {
+                    writer.WriteNullValue();
+                    continue;
+                }
+
+                switch (token)
+                {
+
+                    case JObject jo:
+                        JsonConverter_JObject.Instance.Write(writer, jo, options);
+                        break;
+                    case JArray ja:
+                        Write(writer, ja, options);
+                        break;
+                    case JValue jv:
+                        switch (jv.Type)
+                        {
+                            case JTokenType.String: writer.WriteStringValue(jv.Value<string>()); break;
+                            case JTokenType.Integer: writer.WriteNumberValue(jv.Value<long>()); break;
+                            case JTokenType.Float: writer.WriteNumberValue(jv.Value<double>()); break;
+                            case JTokenType.Boolean: writer.WriteBooleanValue(jv.Value<bool>()); break;
+                            case JTokenType.Date: writer.WriteStringValue(jv.Value<DateTime>().ToString("yyyy-MM-dd HH:mm:ss")); break;
+
+                            default: writer.WriteStringValue(Serialization_Newtonsoft.Instance.SerializeToString(jv)); break;
+                        }
+                        break;
+                    default:
+                        string str = Serialization_Newtonsoft.Instance.SerializeToString(token);
+                        writer.WriteStringValue(str);
+                        break;
+                }
+            }
+
+
+            writer.WriteEndArray();
+
+        }
+
+
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override JArray Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            if (reader.TokenType != JsonTokenType.StartArray) return null;
+
+
+            var result = new JArray();
+
+            while (true)
+            {
+                if (!reader.Read())
+                {
+                    throw new ArgumentException("json read error");
+                }
+
+                if (reader.TokenType == JsonTokenType.EndArray)
+                {
+                    reader.Skip();
+                    break;
+                }              
+
+
+                switch (reader.TokenType)
+                {
+                    case JsonTokenType.StartObject:
+                        result.Add(JsonConverter_JObject.Instance.Read(ref reader, typeof(JObject), options));
+                        break;
+                    case JsonTokenType.StartArray:
+                        result.Add(Read(ref reader, typeof(JArray), options));
+                        break;
+                    case JsonTokenType.String: result.Add(reader.GetString()); break;
+                    case JsonTokenType.Number:
+                        if (reader.TryGetInt32(out var int32))
+                        {
+                            result.Add(int32);
+                            break;
+                        }
+                        if (reader.TryGetInt64(out var int64))
+                        {
+                            result.Add(int64);
+                            break;
+                        }
+                        if (reader.TryGetDouble(out var d))
+                        {
+                            result.Add(d);
+                            break;
+                        }
+
+                        if (reader.TryGetSingle(out var sing))
+                        {
+                            result.Add(sing);
+                            break;
+                        }
+                        if (reader.TryGetDecimal(out var dec))
+                        {
+                            result.Add(dec);
+                            break;
+                        }
+                        result.Add(null);
+                        break;
+                    case JsonTokenType.False: result.Add(false); break;
+                    case JsonTokenType.True: result.Add(true); break;
+                    //case JsonTokenType.Null: break;
+                    //case JsonTokenType.None: break;
+                    default: result.Add(null); break;
+                }
+            }
+
+            return result;
+
+        }
+
+
+    }
+    #endregion
+}
+
+#endregion