refactor(Utils): Refactor the Union class to improve type safety and state management

- Introduce the `UnionValueState` enum to explicitly track the currently stored value type
- Refactor the constructor for safer initialization logic and add type compatibility checks
- Override the `Equals`, `GetHashCode`, and `ToString` methods to comply with object conventions
- Rename generic parameters from `TA`/`TB` to `T1`/`T2` for better consistency
- Fix the logic for implicit conversion and value access to avoid null reference exceptions

Author: Yushu2606

src/Utils/Union.cs

@@ -6,66 +6,116 @@
 
 namespace Limekuma.Utils;
 
+internal enum UnionValueState
+{
+    Empty,
+    First,
+    Second
+}
+
 [JsonConverter(typeof(UnionJsonConverter))]
-public class Union<TA, TB>
+public sealed class Union<T1, T2>
 {
-    private readonly TA? _valueA;
-    private readonly TB? _valueB;
+    private readonly T1? _value1;
+    private readonly T2? _value2;
+    private readonly UnionValueState _valueState = UnionValueState.Empty;
 
-    public Union(TA? value) => _valueA = value;
-    public Union(TB? value) => _valueB = value;
+    public Union(T1? value) : this()
+    {
+        if (value is null)
+        {
+            return;
+        }
+
+        _valueState = UnionValueState.First;
+        _value1 = value;
+    }
 
-    public Union(object? obj)
+    public Union(T2? value) : this()
     {
-        if (obj is null)
+        if (value is null)
         {
             return;
         }
 
-        if (obj is TA valueA)
+        _valueState = UnionValueState.Second;
+        _value2 = value;
+    }
+
+    public Union(object? value) : this()
+    {
+        switch (value)
+        {
+            case null:
+                return;
+            case T1 value1:
+                _valueState = UnionValueState.First;
+                _value1 = value1;
+                break;
+            case T2 value2:
+                _valueState = UnionValueState.Second;
+                _value2 = value2;
+                break;
+            default:
+                throw new ArgumentException($"Union value must be of type {typeof(T1).Name} or {typeof(T2).Name}.", nameof(value));
+        }
+    }
+
+    private Union()
+    {
+        if (typeof(T1).IsAssignableFrom(typeof(T2)))
         {
-            _valueA = valueA;
+            throw new ArgumentException($"Union value type {typeof(T1).Name} is assignable from type {typeof(T2).Name}.");
         }
 
-        if (obj is TB valueB)
+        if (typeof(T2).IsAssignableFrom(typeof(T1)))
         {
-            _valueB = valueB;
+            throw new ArgumentException($"Union value type {typeof(T2).Name} is assignable from type {typeof(T1).Name}.");
         }
     }
 
     public object? Value
     {
         get
         {
-            if (_valueA is not null)
+            return _valueState switch
             {
-                return _valueA;
-            }
-
-            if (_valueB is not null)
-            {
-                return _valueB;
-            }
-
-            return null;
+                UnionValueState.Empty => null,
+                UnionValueState.First => _value1,
+                UnionValueState.Second => _value2,
+                _ => throw new InvalidOperationException($"Union value type {_valueState} is not valid."),
+            };
         }
     }
 
-    public static implicit operator TA?(Union<TA, TB> o) => o._valueA;
+    public static implicit operator T1?(Union<T1, T2> o) => o._value1;
 
-    public static implicit operator TB?(Union<TA, TB> o) => o._valueB;
+    public static implicit operator T2?(Union<T1, T2> o) => o._value2;
 
-    public static implicit operator Union<TA, TB>(TA a) => new(a);
+    public static implicit operator Union<T1, T2>(T1 a) => new(a);
 
-    public static implicit operator Union<TA, TB>(TB b) => new(b);
+    public static implicit operator Union<T1, T2>(T2 b) => new(b);
 
-    public new Type? GetType() => Value?.GetType();
+    public Type? ValueType => Value?.GetType();
 
-    public new string? ToString() => Value?.ToString();
+    public override string? ToString() => Value?.ToString();
 
-    public new bool? Equals(object? obj) => Value?.Equals(obj);
+    public override bool Equals(object? obj)
+    {
+        if (obj is Union<T1, T2> value)
+        {
+            if (value._valueState != _valueState)
+            {
+                return false;
+            }
+
+            return Value?.Equals(value.Value) ?? value.Value is null;
+        }
+
+        return Value?.Equals(obj) ?? obj is null;
+    }
 
-    public new int? GetHashCode() => Value?.GetHashCode();
+    public override int GetHashCode() => Value?.GetHashCode() ?? 0;
 }
 
 public sealed class UnionJsonConverter : JsonConverterFactory