dotnet/Library/Sers/Sers.Serslot/Sers.Serslot/SerslotServer.cs

@@ -139,15 +139,17 @@ namespace Sers.Serslot
         // Graceful shutdown if possible
         public async Task StopAsync(CancellationToken cancellationToken)
         {
-
-            try
+            await Task.Run(() =>
             {
-                ServiceStation.ServiceStation.Stop();
-            }
-            catch (Exception ex)
-            {
-                Logger.Error(ex);
-            }
+                try
+                {
+                    ServiceStation.ServiceStation.Stop();
+                }
+                catch (Exception ex)
+                {
+                    Logger.Error(ex);
+                }
+            });
         }
 
         // Ungraceful shutdown

dotnet/Library/Vit/Vit.Core/Test/Vit.Core.MsTest/Module/SerializationTest.cs

@@ -30,13 +30,13 @@ namespace Vit.Core.MsTest.Module
 
 
             #region (x.2)object <--> String
-            Assert.AreEqual(Serialization.Instance.DeserializeFromString<ModelA>(Serialization.Instance.SerializeToString(modelA))?.name, testString);
+            Assert.AreEqual(Json.Instance.DeserializeFromString<ModelA>(Json.Instance.SerializeToString(modelA))?.name, testString);
             Assert.AreEqual(modelA.Serialize().Deserialize<ModelA>()?.name, testString);
             #endregion
 
 
             #region (x.3)object <--> bytes
-            Assert.AreEqual(Serialization.Instance.DeserializeFromBytes<ModelA>(Serialization.Instance.SerializeToBytes(modelA))?.name, testString);
+            Assert.AreEqual(Json.Instance.DeserializeFromBytes<ModelA>(Json.Instance.SerializeToBytes(modelA))?.name, testString);
             Assert.AreEqual(modelA.SerializeToBytes().DeserializeFromBytes<ModelA>()?.name, testString);
             #endregion
  

dotnet/Library/Vit/Vit.Core/Vit.Core/Module/Serialization/Extensions/ObjectSerializeExtensions.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Runtime.CompilerServices;
+
 using Vit.Core.Module.Serialization;
 
 namespace Vit.Extensions
@@ -20,7 +21,7 @@ namespace Vit.Extensions
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static string Serialize(this object value)
         {
-            return Serialization.Instance.SerializeToString(value);
+            return Json.SerializeToString(value);
         }
         #endregion
 
@@ -36,7 +37,7 @@ namespace Vit.Extensions
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static object Deserialize(this string value, Type type)
         {
-            return Serialization.Instance.DeserializeFromString(value, type);
+            return Json.DeserializeFromString(value, type);
         }
 
         /// <summary>
@@ -48,7 +49,7 @@ namespace Vit.Extensions
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static T Deserialize<T>(this string value)
         {
-            return Serialization.Instance.DeserializeFromString<T>(value);
+            return Json.DeserializeFromString<T>(value);
         }
 
         #endregion
@@ -67,7 +68,7 @@ namespace Vit.Extensions
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static byte[] SerializeToBytes(this object value)
         {
-            return Serialization.Instance.SerializeToBytes(value);
+            return Json.SerializeToBytes(value);
         }
         #endregion
 
@@ -81,7 +82,7 @@ namespace Vit.Extensions
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static T DeserializeFromBytes<T>(this byte[] value)
         {
-            return Serialization.Instance.DeserializeFromBytes<T>(value);
+            return Json.DeserializeFromBytes<T>(value);
         }
 
         /// <summary>
@@ -93,7 +94,7 @@ namespace Vit.Extensions
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static object DeserializeFromBytes(this byte[] value, Type type)
         {
-            return Serialization.Instance.DeserializeFromBytes(value, type);
+            return Json.DeserializeFromBytes(value, type);
         }
         #endregion
 
@@ -102,7 +103,7 @@ namespace Vit.Extensions
 
         #region (x.3)object <--> ArraySegmentByte
 
-        #region SerializeToArraySegmentByte
+
         /// <summary>
         /// 
         /// </summary>
@@ -111,12 +112,12 @@ namespace Vit.Extensions
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static ArraySegment<byte> SerializeToArraySegmentByte(this object value)
         {
-            return Serialization.Instance.SerializeToBytes(value).BytesToArraySegmentByte();
+            return Json.SerializeToArraySegmentByte(value);
         }
-        #endregion
 
 
-        #region DeserializeFromArraySegmentByte
+
+
         /// <summary>
         /// 
         /// </summary>
@@ -126,7 +127,7 @@ namespace Vit.Extensions
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static T DeserializeFromArraySegmentByte<T>(this ArraySegment<byte> value)
         {
-            return Serialization_Newtonsoft.Instance.DeserializeFromArraySegmentByte<T>(value);
+            return Json.DeserializeFromArraySegmentByte<T>(value);
         }
 
         /// <summary>
@@ -138,12 +139,12 @@ namespace Vit.Extensions
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static object DeserializeFromArraySegmentByte(this ArraySegment<byte> value, Type type)
         {
-            return Serialization_Newtonsoft.Instance.DeserializeFromArraySegmentByte(value, type);
+            return Json.DeserializeFromArraySegmentByte(value, type);
         }
-        #endregion
+
         #endregion
 
-               
+
 
 
 
@@ -160,8 +161,8 @@ namespace Vit.Extensions
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static object ConvertBySerialize(this object value, Type type)
         {
-            var str = Serialization.Instance.SerializeToString(value);
-            return Serialization.Instance.DeserializeFromString(str, type); 
+            var str = Json.SerializeToString(value);
+            return Json.DeserializeFromString(str, type);
         }
 
         /// <summary>
@@ -173,13 +174,13 @@ namespace Vit.Extensions
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static TTarget ConvertBySerialize<TTarget>(this object value)
         {
-            var str = Serialization.Instance.SerializeToString(value);
-            return Serialization.Instance.DeserializeFromString<TTarget>(str);
+            var str = Json.SerializeToString(value);
+            return Json.DeserializeFromString<TTarget>(str);
         }
         #endregion
 
 
-       
+
 
 
 

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

@@ -7,12 +7,37 @@ namespace Vit.Core.Module.Serialization
 
         #region (x.1)object <--> String
 
+        /// <summary>
+        /// T也可为值类型（例如 int?、bool） 
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="value"></param>
+        /// <returns></returns>
         string SerializeToString<T>(T value);
+
+        /// <summary>
+        /// T也可为值类型（例如 int?、bool） 
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="type"></param>
+        /// <returns></returns>
         string SerializeToString(object value, Type type);
 
 
 
+        /// <summary>
+        /// 使用Newtonsoft反序列化。T也可为值类型（例如 int?、bool） 
+        /// </summary>
+        /// <param name="value"></param>    
+        /// <returns></returns>
         T DeserializeFromString<T>(string value);
+
+        /// <summary>
+        /// 使用Newtonsoft反序列化。T也可为值类型（例如 int?、bool） 
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="type"></param>
+        /// <returns></returns>
         object DeserializeFromString(string value, Type type);
 
         #endregion
@@ -21,18 +46,43 @@ namespace Vit.Core.Module.Serialization
 
         #region (x.2)object <--> bytes
 
+        /// <summary>
+        /// T 可以为   byte[]、string、 object 、struct
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="obj"></param>
+        /// <returns></returns>
         byte[] SerializeToBytes<T>(T obj);
-        byte[] SerializeToBytes(object value, Type type);
 
+        /// <summary>
+        /// type 可以为   byte[]、string、 object 、struct
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        byte[] SerializeToBytes(object value, Type type);
 
+        /// <summary>
+        /// type 可以为   byte[]、string、 object 、struct
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="bytes"></param>
+        /// <returns></returns>
         T DeserializeFromBytes<T>(byte[] bytes);
+
+        /// <summary>
+        /// type 可以为   byte[]、string、 object 、struct
+        /// </summary>
+        /// <param name="bytes"></param>
+        /// <param name="type"></param>
+        /// <returns></returns>
         object DeserializeFromBytes(byte[] bytes, Type type);
 
         #endregion
 
 
 
-        #region (x.3)DeserializeFromSpan
+        #region (x.3)object <--> Span
 
         //T DeserializeFromSpan<T>(ReadOnlyMemory<byte> bytes);
 
@@ -42,7 +92,7 @@ namespace Vit.Core.Module.Serialization
 
 
 
-        #region (x.4)DeserializeFromArraySegmentByte
+        #region (x.4)object <--> ArraySegmentByte
 
         T DeserializeFromArraySegmentByte<T>(ArraySegment<byte> bytes);
 

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

@@ -0,0 +1,166 @@
+
+using System;
+using System.Runtime.CompilerServices;
+
+using Vit.Extensions;
+
+namespace Vit.Core.Module.Serialization
+{
+    public static class Json
+    {
+
+        public static ISerialization Instance { get; set; } = Serialization_Newtonsoft.Instance;
+
+
+        #region (x.1)object <--> String
+
+        /// <summary>
+        /// T也可为值类型（例如 int?、bool） 
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static string SerializeToString<T>(T value)
+        {
+            return Instance.SerializeToString<T>(value);
+        }
+
+        /// <summary>
+        /// T也可为值类型（例如 int?、bool） 
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static string SerializeToString(object value, Type type)
+        {
+            return Instance.SerializeToString(value, type);
+        }
+
+
+
+        /// <summary>
+        /// 使用Newtonsoft反序列化。T也可为值类型（例如 int?、bool） 
+        /// </summary>
+        /// <param name="value"></param>    
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static T DeserializeFromString<T>(string value)
+        {
+            return Instance.DeserializeFromString<T>(value);
+        }
+
+        /// <summary>
+        /// 使用Newtonsoft反序列化。T也可为值类型（例如 int?、bool） 
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static object DeserializeFromString(string value, Type type)
+        {
+            return Instance.DeserializeFromString(value, type);
+        }
+
+        #endregion
+
+
+
+        #region (x.2)object <--> bytes
+
+        /// <summary>
+        /// T 可以为   byte[]、string、 object 、struct
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="obj"></param>
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static byte[] SerializeToBytes<T>(T obj)
+        {
+            return Instance.SerializeToBytes<T>(obj);
+        }
+
+        /// <summary>
+        /// type 可以为   byte[]、string、 object 、struct
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static byte[] SerializeToBytes(object value, Type type)
+        {
+            return Instance.SerializeToBytes(value, type);
+        }
+
+        /// <summary>
+        /// type 可以为   byte[]、string、 object 、struct
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="bytes"></param>
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static T DeserializeFromBytes<T>(byte[] bytes)
+        {
+            return Instance.DeserializeFromBytes<T>(bytes);
+        }
+
+        /// <summary>
+        /// type 可以为   byte[]、string、 object 、struct
+        /// </summary>
+        /// <param name="bytes"></param>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static object DeserializeFromBytes(byte[] bytes, Type type)
+        {
+            return Instance.DeserializeFromBytes(bytes, type);
+        }
+
+        #endregion
+
+
+
+        #region (x.3)object <--> Span
+
+        //T DeserializeFromSpan<T>(ReadOnlyMemory<byte> bytes);
+
+        //object DeserializeFromSpan(ReadOnlyMemory<byte> bytes, Type type);
+
+        #endregion
+
+
+
+        #region (x.4)object <--> ArraySegmentByte
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ArraySegment<byte> SerializeToArraySegmentByte(this object value)
+        {
+            return Instance.SerializeToBytes(value).BytesToArraySegmentByte();
+        }
+
+
+
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static T DeserializeFromArraySegmentByte<T>(ArraySegment<byte> bytes)
+        {
+            return Instance.DeserializeFromArraySegmentByte<T>(bytes);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static object DeserializeFromArraySegmentByte(ArraySegment<byte> bytes, Type type)
+        {
+            return Instance.DeserializeFromArraySegmentByte(bytes, type);
+        }
+
+        #endregion
+
+    }
+}

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

@@ -0,0 +1,20 @@
+
+
+
+using System;
+
+namespace Vit.Core.Module.Serialization
+{
+    /// <summary>
+    /// please use Vit.Core.Module.Serialization.Json instead
+    /// </summary>
+    [Obsolete("use Vit.Core.Module.Serialization.Json instead")]
+    public class Serialization
+    {
+        /// <summary>
+        /// please use Vit.Core.Module.Serialization.Json.Instance instead
+        /// </summary>
+        [Obsolete("use Vit.Core.Module.Serialization.Json.Instance instead")]
+        public static ISerialization Instance => Json.Instance;
+    }
+}

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

@@ -1,12 +0,0 @@
- 
-
-
-namespace Vit.Core.Module.Serialization
-{
-    public  abstract class Serialization
-    {
-
-        public static ISerialization Instance { get; set; } = Serialization_Newtonsoft.Instance;
-
-    }
-}

dotnet/Library/Vit/Vit.Core/Vit.Core/Util/ConfigurationManager/ConfigurationManager.cs

@@ -1,19 +0,0 @@
-
-namespace Vit.Core.Util.ConfigurationManager
-{
-
-    /// <summary>
-    /// please repace this with Vit.Core.Util.ConfigurationManager.Appsetting
-    /// </summary>
-    //[Obsolete("use Vit.Core.Util.ConfigurationManager.Appsetting instead.")]
-    public class ConfigurationManager
-    {
-
-        /// <summary>
-        /// please repace this with Vit.Core.Util.ConfigurationManager.Appsetting.json
-        /// </summary>
-        //[Obsolete("use Vit.Core.Util.ConfigurationManager.Appsetting.json instead.")]
-        public static JsonFile Instance => Appsettings.json;
-
-    }
-}

dotnet/Library/Vit/Vit.Core/Vit.Core/Util/ConfigurationManager/Obsolete/ConfigurationManager.cs

@@ -0,0 +1,21 @@
+
+using System;
+
+namespace Vit.Core.Util.ConfigurationManager
+{
+
+    /// <summary>
+    /// please use Vit.Core.Util.ConfigurationManager.Appsetting instead
+    /// </summary>
+    [Obsolete("use Vit.Core.Util.ConfigurationManager.Appsetting instead")]
+    public class ConfigurationManager
+    {
+
+        /// <summary>
+        /// please use Vit.Core.Util.ConfigurationManager.Appsetting.json instead
+        /// </summary>
+        [Obsolete("use Vit.Core.Util.ConfigurationManager.Appsetting.json instead")]
+        public static JsonFile Instance => Appsettings.json;
+
+    }
+}

dotnet/Library/Vit/Vit.Core/Vit.Core/Util/Net/HttpClient.cs

@@ -48,7 +48,7 @@ namespace Vit.Core.Util.Net
                         httpRequest.Content = httpContent;
                         break;
                     default:
-                        var content = Serialization.Instance.SerializeToString(request.body);
+                        var content = Json.Instance.SerializeToString(request.body);
                         httpRequest.Content = new StringContent(content, request.requestEncoding, "application/json");
                         break;
                 }

dotnet/Library/Vit/Vit.Core/Vit.Core/Vit.Core.csproj

@@ -12,7 +12,11 @@
 	<PropertyGroup>
 		<Authors>Lith</Authors>
 		<Description>
-			.net core common tool. log to txt,Serialize(Newtonsoft.Json),ConfigurationManager,DynamicMethodExecutor,Guid,Reflection,Shell etc.
+			.net core common tool.
+			log to txt(Vit.Core.Module.Log.Logger),
+			Serialize(Vit.Core.Module.Serialization.Json),
+			ConfigurationManager(Vit.Core.Util.ConfigurationManager.Appsettings.json),
+			DynamicMethodExecutor, Guid, Reflection, Shell etc.
 			Send email to serset@yeah.net if you have any questions.
 		</Description>
 		<PackageProjectUrl>https://github.com/serset/Sers</PackageProjectUrl>