调整使用 .NET 6/7 新特性

Author: alexinea

src/Cosmos.Core/Cosmos/Exceptions/ExceptionHelper.cs

@@ -1,5 +1,4 @@
 using System.Runtime.ExceptionServices;
-using System.Text;
 using Cosmos.Reflection;
 
 namespace Cosmos.Exceptions;
@@ -30,35 +29,31 @@ public static Exception PrepareForRethrow(Exception exception)
     /// Unwrap<br />
     /// 解包
     /// </summary>
-    /// <param name="ex"></param>
+    /// <param name="exception"></param>
     /// <returns></returns>
-    public static Exception Unwrap(Exception ex)
+    public static Exception Unwrap(Exception exception)
     {
-        if (ex is null)
-            throw new ArgumentNullException(nameof(ex));
-        while (ex.InnerException != null)
-            ex = ex.InnerException;
-        return ex;
+        ArgumentNullException.ThrowIfNull(exception);
+        while (exception.InnerException != null)
+            exception = exception.InnerException;
+        return exception;
     }
 
     /// <summary>
     /// Unwrap<br />
     /// 解包
     /// </summary>
-    /// <param name="ex"></param>
+    /// <param name="exception"></param>
     /// <param name="untilType"></param>
     /// <param name="mayDerivedClass"></param>
     /// <returns></returns>
-    public static Exception Unwrap(Exception ex, Type untilType, bool mayDerivedClass = true)
+    public static Exception Unwrap(Exception exception, Type untilType, bool mayDerivedClass = true)
     {
-        if (ex is null)
-            throw new ArgumentNullException(nameof(ex));
-        if (untilType is null)
-            throw new ArgumentNullException(nameof(untilType));
+        ArgumentNullException.ThrowIfNull(exception);
+        ArgumentNullException.ThrowIfNull(untilType);
         if (!untilType.IsSubclassOf(typeof(Exception)))
             throw new ArgumentException($"Type '{untilType}' does not be divided from {typeof(Exception)}", nameof(untilType));
 
-        var exception = ex;
         return exception.GetType() == untilType || mayDerivedClass && exception.GetType().IsSubclassOf(untilType)
             ? exception
             : exception.InnerException is null
@@ -71,13 +66,12 @@ public static Exception Unwrap(Exception ex, Type untilType, bool mayDerivedClas
     /// 解包
     /// </summary>
     /// <typeparam name="TException"></typeparam>
-    /// <param name="ex"></param>
+    /// <param name="exception"></param>
     /// <returns></returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Exception Unwrap<TException>(Exception ex)
-        where TException : Exception
+    public static Exception Unwrap<TException>(Exception exception) where TException : Exception
     {
-        return ex.Unwrap(Types.Of<TException>());
+        return exception.Unwrap(Types.Of<TException>());
     }
 }
 
@@ -91,63 +85,71 @@ public static class ExceptionHelperExtensions
     /// Unwrap<br />
     /// 解包
     /// </summary>
-    /// <param name="ex"></param>
+    /// <param name="exception"></param>
     /// <returns></returns>
-    public static Exception Unwrap(this Exception ex)
-        => ExceptionHelper.Unwrap(ex);
+    public static Exception Unwrap(this Exception exception)
+    {
+        return ExceptionHelper.Unwrap(exception);
+    }
 
     /// <summary>
     /// Unwrap<br />
     /// 解包
     /// </summary>
-    /// <param name="ex"></param>
+    /// <param name="exception"></param>
     /// <param name="untilType"></param>
     /// <param name="mayDerivedClass"></param>
     /// <returns></returns>
-    public static Exception Unwrap(this Exception ex, Type untilType, bool mayDerivedClass = true)
-        => ExceptionHelper.Unwrap(ex, untilType, mayDerivedClass);
+    public static Exception Unwrap(this Exception exception, Type untilType, bool mayDerivedClass = true)
+    {
+        return ExceptionHelper.Unwrap(exception, untilType, mayDerivedClass);
+    }
 
     /// <summary>
     /// Unwrap<br />
     /// 解包
     /// </summary>
     /// <typeparam name="TException"></typeparam>
-    /// <param name="ex"></param>
+    /// <param name="exception"></param>
     /// <returns></returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Exception Unwrap<TException>(this Exception ex)
-        where TException : Exception
-        => ExceptionHelper.Unwrap<TException>(ex);
+    public static Exception Unwrap<TException>(this Exception exception) where TException : Exception
+    {
+        return ExceptionHelper.Unwrap<TException>(exception);
+    }
 
     /// <summary>
     /// Unwrap and gets message<br />
     /// 解包并返回消息
     /// </summary>
-    /// <param name="ex"></param>
+    /// <param name="exception"></param>
     /// <returns></returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static string ToUnwrappedString(this Exception ex) => ex.Unwrap().Message;
+    public static string ToUnwrappedString(this Exception exception)
+    {
+        return exception.Unwrap().Message;
+    }
 
     /// <summary>
     /// Unwrap and gets full message<br />
     /// 解包，尝试返回完整信息
     /// </summary>
-    /// <param name="ex"></param>
+    /// <param name="exception"></param>
     /// <returns></returns>
-    public static string ToFullUnwrappedString(this Exception ex)
+    public static string ToFullUnwrappedString(this Exception exception)
     {
         var sb = new StringBuilder();
-        if (ex is CosmosException cosmosException)
+        if (exception is CosmosException cosmosException)
         {
             sb.AppendLine(cosmosException.GetFullMessage());
-            if (ex.InnerException != null)
+            if (exception.InnerException != null)
             {
-                sb.Append(ex.InnerException.ToUnwrappedString());
+                sb.Append(exception.InnerException.ToUnwrappedString());
             }
         }
         else
         {
-            sb.Append(ex.ToUnwrappedString());
+            sb.Append(exception.ToUnwrappedString());
         }
 
         return sb.ToString();