feat: 项目初始化 + 3D方块世界原型 + AI助搭系统

初始化 monorepo: Go后端(7微服务) + Unity客户端(9模块) + 启动器

HTML5原型: Three.js 3D体素世界, Perlin噪声地形, 原版材质, 22种方块

Minecraft创造模式背包: 双栏布局, 拖拽移动物品, 方向性元件引脚

AI助搭策划文档 + 客户端/服务端骨架 + Docker Compose + CI

launcher/PCL-CE/PCL.Core/Utils/Exts/AsyncEnumerableExtensions.cs

@@ -0,0 +1,117 @@
+using System;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+
+namespace PCL.Core.Utils.Exts;
+
+public static class AsyncEnumerableExtensions
+{
+    /// <param name="source">源集合</param>
+    /// <typeparam name="T">集合元素类型</typeparam>
+    extension<T>(IEnumerable<T> source)
+    {
+        /// <summary>
+        /// 对集合中的每个元素异步执行指定操作，最多同时运行 maxDegreeOfParallelism 个任务。
+        /// </summary>
+        /// <param name="action">对每个元素执行的异步操作</param>
+        /// <param name="maxDegreeOfParallelism">最大并发数，默认为 10</param>
+        /// <returns>所有任务完成后的任务</returns>
+        public async Task ForEachAsync(
+            Func<T, Task> action,
+            int maxDegreeOfParallelism = 10)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+            ArgumentNullException.ThrowIfNull(action);
+            ArgumentOutOfRangeException.ThrowIfNegativeOrZero(maxDegreeOfParallelism);
+
+            var semaphore = new SemaphoreSlim(maxDegreeOfParallelism);
+
+            var tasks = source.Select(async item =>
+            {
+                await semaphore.WaitAsync();
+                try
+                {
+                    await action(item);
+                }
+                finally
+                {
+                    semaphore.Release();
+                }
+            });
+
+            await Task.WhenAll(tasks);
+        }
+
+        /// <summary>
+        /// 对集合中的每个元素异步执行指定操作，最多同时运行 maxDegreeOfParallelism 个任务。
+        /// </summary>
+        /// <param name="action">对每个元素执行的异步操作</param>
+        /// <param name="maxDegreeOfParallelism">最大并发数，默认为 10</param>
+        /// <param name="cancellationToken">取消令牌</param>
+        /// <returns>所有任务完成后的任务</returns>
+        public async Task ForEachAsync(
+            Func<T, CancellationToken, Task> action,
+            int maxDegreeOfParallelism = 10,
+            CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+            ArgumentNullException.ThrowIfNull(action);
+            ArgumentOutOfRangeException.ThrowIfNegativeOrZero(maxDegreeOfParallelism);
+
+            var semaphore = new SemaphoreSlim(maxDegreeOfParallelism);
+
+            var tasks = source.Select(async item =>
+            {
+                await semaphore.WaitAsync(cancellationToken);
+                try
+                {
+                    await action(item, cancellationToken);
+                }
+                finally
+                {
+                    semaphore.Release();
+                }
+            });
+
+            await Task.WhenAll(tasks);
+        }
+
+        /// <summary>
+        /// 对集合中的每个元素异步执行指定操作，限制并发数，并返回所有操作的结果。
+        /// 等同于：source.Select(x => action(x)).WhenAll()，但有并发控制。
+        /// </summary>
+        /// <typeparam name="TResult">操作返回类型</typeparam>
+        /// <param name="selector">异步选择器函数</param>
+        /// <param name="maxDegreeOfParallelism">最大并发数，默认为 10</param>
+        /// <param name="cancellationToken">取消令牌</param>
+        /// <returns>包含所有操作结果的集合</returns>
+        public async Task<IEnumerable<TResult>> SelectAsync<TResult>(
+            Func<T, Task<TResult>> selector,
+            int maxDegreeOfParallelism = 10,
+            CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+            ArgumentNullException.ThrowIfNull(selector);
+            ArgumentOutOfRangeException.ThrowIfNegativeOrZero(maxDegreeOfParallelism);
+
+            var semaphore = new SemaphoreSlim(maxDegreeOfParallelism);
+
+            var tasks = source.Select(async item =>
+            {
+                await semaphore.WaitAsync(cancellationToken);
+                try
+                {
+                    return await selector(item);
+                }
+                finally
+                {
+                    semaphore.Release();
+                }
+            });
+
+            return await Task.WhenAll(tasks);
+        }
+    }
+}

launcher/PCL-CE/PCL.Core/Utils/Exts/ByteExtension.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace PCL.Core.Utils.Exts;
+
+public static class ByteExtension
+{
+    extension(ReadOnlySpan<byte> bytes)
+    {
+        public string ToHexString() => Convert.ToHexString(bytes).ToLower();
+        public string FromByteToB64() => Convert.ToBase64String(bytes);
+        public string FromBytesToB64UrlSafe() => bytes.FromByteToB64().FromB64ToB64UrlSafe();
+    }
+}

launcher/PCL-CE/PCL.Core/Utils/Exts/ConcurrentDictionaryExtension.cs

@@ -0,0 +1,29 @@
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+
+namespace PCL.Core.Utils.Exts;
+
+public static class ConcurrentDictionaryExtension
+{
+    extension<TKey, TValue>(ConcurrentDictionary<TKey, TValue> dict) where TKey: notnull
+    {
+        public bool CompareAndRemove(TKey key,
+            TValue comparison) => ((ICollection<KeyValuePair<TKey, TValue>>)dict).Remove(new KeyValuePair<TKey, TValue>(key, comparison));
+
+        public TValue? UpdateAndGetPrevious(TKey key,
+            TValue value)
+        {
+            TValue? prevValue = default;
+            dict.AddOrUpdate(key, _ =>
+            {
+                prevValue = default;
+                return value;
+            }, (_, existingValue) =>
+            {
+                prevValue = existingValue;
+                return value;
+            });
+            return prevValue;
+        }
+    }
+}

launcher/PCL-CE/PCL.Core/Utils/Exts/HttpRequestExtension.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net.Http;
+using System.Threading.Tasks;
+
+namespace PCL.Core.Utils.Exts;
+
+public static class HttpRequestExtension
+{
+    public static async Task<HttpRequestMessage> CloneAsync(this HttpRequestMessage request)
+    {
+        ArgumentNullException.ThrowIfNull(request);
+
+        var clone = new HttpRequestMessage(request.Method, request.RequestUri)
+        {
+            Version = request.Version,
+            VersionPolicy = request.VersionPolicy
+        };
+
+        if (request.Content is not null)
+        {
+            clone.Content = await request.Content._DeepCloneAsync().ConfigureAwait(false);
+        }
+
+        foreach (var header in request.Headers)
+        {
+            clone.Headers.TryAddWithoutValidation(header.Key, header.Value);
+        }
+
+        foreach (var option in request.Options)
+        {
+            clone.Options.TryAdd(option.Key, option.Value);
+        }
+
+        return clone;
+    }
+
+    private static async Task<HttpContent?> _DeepCloneAsync(this HttpContent content)
+    {
+        var ms = new MemoryStream();
+        await content.CopyToAsync(ms).ConfigureAwait(false);
+        ms.Position = 0;
+
+        var clone = new StreamContent(ms);
+
+        // 复制内容头（如 Content-Type, Content-Length 等）
+        foreach (var header in content.Headers)
+        {
+            clone.Headers.TryAddWithoutValidation(header.Key, header.Value);
+        }
+
+        return clone;
+    }
+}

launcher/PCL-CE/PCL.Core/Utils/Exts/LanguageSpecificStringDictionaryExtensions.cs

@@ -0,0 +1,38 @@
+using System.Globalization;
+using System.Linq;
+using System.Windows.Markup;
+using System.Windows.Media;
+
+namespace PCL.Core.Utils.Exts;
+
+public static class LanguageSpecificStringDictionaryExtensions
+{
+    public static string GetForCurrentUiCulture(this LanguageSpecificStringDictionary dict, string? fallback = null)
+    {
+        var ui = CultureInfo.CurrentUICulture;
+
+        // 1) 精确匹配，如 zh-Hans-CN
+        if (TryFromTag(dict, ui.IetfLanguageTag, out var v))
+            return v;
+
+        // 2) 逐级回退，如 zh-Hans-CN -> zh-Hans -> zh
+        var tag = ui.IetfLanguageTag;
+        for (var dash = tag.LastIndexOf('-'); dash > 0; dash = tag.LastIndexOf('-'))
+        {
+            tag = tag.Substring(0, dash);
+            if (TryFromTag(dict, tag, out v))
+                return v;
+        }
+
+        // 3) 再尝试父文化（当 CurrentUICulture 是特定文化时）
+        if (!ui.IsNeutralCulture && TryFromTag(dict, ui.Parent.IetfLanguageTag, out v))
+            return v;
+
+        // 4) 兜底：取字典中的第一个值，或使用传入的 fallback，或空字符串
+        if (dict.Count > 0) return dict.Values!.First();
+        return fallback ?? string.Empty;
+
+        static bool TryFromTag(LanguageSpecificStringDictionary d, string ietf, out string value)
+            => d.TryGetValue(XmlLanguage.GetLanguage(ietf), out value!);
+    }
+}

launcher/PCL-CE/PCL.Core/Utils/Exts/ListExtension.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+
+namespace PCL.Core.Utils.Exts;
+
+public static class ListUtils
+{
+    extension<T>(IEnumerable<T> source)
+    {
+        /// <summary>
+        /// 选择最大值对应的对象。
+        /// 若没有元素则返回 default(T)。
+        /// </summary>
+        public T? MaxOrDefault<C>(Func<T, C> selector) where C : IComparable<C>
+        {
+            using var enumerator = source.GetEnumerator();
+            if (!enumerator.MoveNext()) return default;
+            var maxItem = enumerator.Current;
+            var maxValue = selector(maxItem);
+            while (enumerator.MoveNext())
+            {
+                var value = selector(enumerator.Current);
+                if (value.CompareTo(maxValue) <= 0) continue;
+                maxItem = enumerator.Current;
+                maxValue = value;
+            }
+            return maxItem;
+        }
+
+        /// <summary>
+        /// 选择最小值对应的对象。
+        /// 若没有元素则返回 default(T)。
+        /// </summary>
+        public T? MinOrDefault<C>(Func<T, C> selector) where C : IComparable<C>
+        {
+            using var enumerator = source.GetEnumerator();
+            if (!enumerator.MoveNext()) return default;
+            var minItem = enumerator.Current;
+            var minValue = selector(minItem);
+            while (enumerator.MoveNext())
+            {
+                var value = selector(enumerator.Current);
+                if (value.CompareTo(minValue) >= 0) continue;
+                minItem = enumerator.Current;
+                minValue = value;
+            }
+            return minItem;
+        }
+    }
+}
+
+public static class SortUtils {
+    /// <summary>
+    /// 对列表进行稳定排序，返回新列表。
+    /// </summary>
+    /// <typeparam name="T">列表元素类型。</typeparam>
+    /// <param name="list">要排序的列表。</param>
+    /// <param name="comparison">比较器，接收两个对象，若第一个对象应排在前面，则返回 true。</param>
+    /// <returns>排序后的新列表。</returns>
+    public static List<T> Sort<T>(this IList<T> list, Func<T, T, bool> comparison) {
+        // 创建新列表以避免修改原始列表
+        var result = new List<T>(list);
+        result.Sort(new StableComparer<T>(comparison));
+        return result;
+    }
+
+    private class StableComparer<T>(Func<T, T, bool> comparison) : IComparer<T> {
+        private readonly Func<T, T, bool> _comparison = comparison ?? throw new ArgumentNullException(nameof(comparison));
+
+        public int Compare(T? x, T? y) {
+            if (x is null && y is null) return 0;
+            if (x is null) return -1;
+            if (y is null) return 1;
+
+            var xComesFirst = _comparison(x, y);
+            var yComesFirst = _comparison(y, x);
+
+            if (!xComesFirst && !yComesFirst) return 0; // 相等，保持稳定
+            return xComesFirst ? -1 : 1; // x 在前返回 -1，否则返回 1
+        }
+    }
+}

launcher/PCL-CE/PCL.Core/Utils/Exts/StringExtension.cs

@@ -0,0 +1,292 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Linq;
+using System.Numerics;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Text.RegularExpressions;
+
+namespace PCL.Core.Utils.Exts;
+
+public static class StringConvertExtension
+{
+    public static object? Convert(string? value, Type targetType)
+    {
+        ArgumentNullException.ThrowIfNull(targetType);
+
+        if (targetType == typeof(string)) return value;
+
+        if (value is null)
+        {
+            if (!targetType.IsValueType || Nullable.GetUnderlyingType(targetType) is not null) return null;
+            return Activator.CreateInstance(targetType);
+        }
+
+        var converter = TypeDescriptor.GetConverter(targetType);
+
+        if (converter.CanConvertFrom(typeof(string)))
+        {
+            var c = converter.ConvertFromInvariantString(value);
+            return c;
+        }
+
+        if (typeof(IConvertible).IsAssignableFrom(targetType))
+        {
+            // ReSharper disable once RedundantSuppressNullableWarningExpression
+            var changed = System.Convert.ChangeType(value, targetType, CultureInfo.InvariantCulture)!;
+            return changed;
+        }
+
+        if (targetType.IsEnum) return Enum.Parse(targetType, value, ignoreCase: true);
+
+        var parse = targetType.GetMethod("Parse",
+            BindingFlags.Public | BindingFlags.Static,
+            binder: null, types: [typeof(string)], modifiers: null);
+        if (parse is not null) return parse.Invoke(null, [value]);
+
+        throw new NotSupportedException($"无法将字符串转换为类型 {targetType.FullName}");
+    }
+
+    public static T? Convert<T>(this string? value)
+    {
+        var obj = Convert(value, typeof(T));
+        if (obj is null) return default;
+        return (T)obj;
+    }
+}
+
+public static class StringExtension
+{
+    public static string? ConvertToString(object? obj)
+    {
+        if (obj is null) return null;
+        if (obj is string s) return s;
+
+        var converter = TypeDescriptor.GetConverter(obj.GetType());
+        if (converter.CanConvertTo(typeof(string)))
+        {
+            object? o = converter.ConvertToInvariantString(obj);
+            return o as string;
+        }
+
+        if (obj is IFormattable fmt) return fmt.ToString(null, CultureInfo.InvariantCulture);
+
+        return obj.ToString();
+    }
+
+    public static string? ConvertToString<T>(this T? value) => ConvertToString((object?)value);
+
+    private static readonly char[] _B36Map = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray();
+
+    extension(string input)
+    {
+        public string FromB10ToB36()
+        {
+            var n = BigInteger.Parse(input);
+            var s = new List<char>();
+            while (n > 0)
+            {
+                var i = (n % 36).ToByteArray()[0];
+                s.Add(_B36Map[i]);
+                n /= 36;
+            }
+            s.Reverse();
+            return string.Join("", s);
+        }
+
+        public string FromB36ToB10()
+        {
+            var ns = input.Select(c => (c is >= '0' and <= '9') ? c - '0' : c - 'A' + 10).ToArray();
+            var nb = ns.Aggregate(new BigInteger(0), (n, i) => n * 36 + i);
+            return nb.ToString();
+        }
+    }
+
+    private static readonly char[] _B32Map = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ".ToCharArray();
+
+    extension(string input)
+    {
+        /// <summary>
+        /// 将 Base10 文本重新编码为 Base32 文本。
+        /// </summary>
+        public string FromB10ToB32()
+        {
+            var n = BigInteger.Parse(input);
+            var s = new List<char>();
+            while (n > 0)
+            {
+                var i = (n % 32).ToByteArray()[0];
+                s.Add(_B32Map[i]);
+                n /= 32;
+            }
+            s.Reverse();
+            return string.Join("", s);
+        }
+
+        /// <summary>
+        /// 将 Base32 文本重新编码为 Base10 文本。
+        /// </summary>
+        public string FromB32ToB10()
+        {
+            var ns = input.Select(Parse).ToArray();
+            var nb = ns.Aggregate(new BigInteger(0), (n, i) => n * 32 + i);
+            return nb.ToString();
+
+            int Parse(char c) => c switch
+            {
+                >= '2' and <= '9' => c - '2',
+                >= 'A' and <= 'H' => c - 'A' + 8,
+                >= 'J' and <= 'N' => c - 'J' + 16,
+                >= 'P' and <= 'Z' => c - 'P' + 21,
+                _ => throw new ArgumentOutOfRangeException(nameof(input), $"Character '{c}' out of Base32 range")
+            };
+        }
+
+        public string FromB64ToB64UrlSafe() => input.Replace("+", "-").Replace("/", "_");
+        public string FromB64UrlSafeToB64() => input.Replace("-", "+").Replace("_", "/");
+
+        public byte[] FromB64ToBytes()
+        {
+            switch (input.Length % 4)
+            {
+                case 3:
+                    input += "===";
+                    break;
+                case 2:
+                    input += "==";
+                    break;
+                case 1:
+                    input += "=";
+                    break;
+            }
+
+            return Convert.FromBase64String(input);
+        }
+
+        public byte[] FromB64UrlSafeToBytes() => input.FromB64UrlSafeToB64().FromB64ToBytes();
+    }
+
+    extension(string input)
+    {
+
+        public T ParseToEnum<T>() where T : struct, Enum
+        {
+            if (String.IsNullOrWhiteSpace(input))
+            {
+                return (T)(object)0;
+            }
+            else if (int.TryParse(input, out int numericValue))
+            {
+                return (T)(object)numericValue;
+            }
+            else
+            {
+                return Enum.Parse<T>(input, true);
+            }
+        }
+    }
+
+    extension([NotNullWhen(false)] string? value)
+    {
+        /// <summary>
+        /// <see cref="string.IsNullOrEmpty"/> 的扩展方法。
+        /// </summary>
+        public bool IsNullOrEmpty() => string.IsNullOrEmpty(value);
+
+        /// <summary>
+        /// <see cref="string.IsNullOrWhiteSpace"/> 的扩展方法。
+        /// </summary>
+        public bool IsNullOrWhiteSpace() => string.IsNullOrWhiteSpace(value);
+    }
+
+    /// <param name="input">文本</param>
+    extension(string? input)
+    {
+        /// <summary>
+        /// 当文本为空时返回替代文本，否则返回原来的文本。
+        /// </summary>
+        /// <param name="replacement">替代文本</param>
+        public string ReplaceNullOrEmpty(string? replacement = null)
+            => string.IsNullOrEmpty(input) ? (replacement ?? string.Empty) : input;
+
+        /// <summary>
+        /// 替换指定文本中的所有换行符。
+        /// </summary>
+        /// <param name="replacement">用于替换的文本</param>
+        /// <returns>替换后的文本</returns>
+        public string ReplaceLineBreak(string replacement = " ")
+            => input?.Replace(RegexPatterns.NewLine, replacement) ?? string.Empty;
+
+        /// <summary>
+        /// 替换指定文本中所有匹配正则表达式的部分。
+        /// </summary>
+        /// <param name="regex">正则表达式</param>
+        /// <param name="replacement">用于替换的文本</param>
+        /// <returns>替换后的文本</returns>
+        [return: NotNullIfNotNull(nameof(input))]
+        public string? Replace(Regex regex, string replacement)
+            => input is null ? null : regex.Replace(input, replacement);
+
+        /// <summary>
+        /// 判断指定文本是否能成功匹配正则表达式。
+        /// </summary>
+        /// <param name="regex">正则表达式</param>
+        /// <returns>若匹配成功则为 <c>true</c>，若文本为 <c>null</c> 或匹配不成功则为 <c>false</c></returns>
+        public bool IsMatch(Regex regex)
+            => input is not null && regex.IsMatch(input);
+    }
+
+    extension(string str)
+    {
+        /// <summary>
+        /// 查找并返回指定文本中所有与正则表达式匹配的部分。
+        /// </summary>
+        public List<string> RegexSearch(Regex regex)
+        {
+            var result = new List<string>();
+            var regexSearchRes = regex.Matches(str);
+            if (regexSearchRes.Count == 0) return result;
+            result.AddRange(from Match item in regexSearchRes select item.Value);
+            return result;
+        }
+
+        /// <summary>
+        /// 判断指定文本是否在 ASCII 范围内。
+        /// </summary>
+        // ReSharper disable once InconsistentNaming
+        public bool IsASCII()
+        {
+            return str.All(c => c < 128);
+        }
+
+        public bool StartsWithF(string prefix, bool ignoreCase = false)
+            => str.StartsWith(prefix, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
+
+        public bool EndsWithF(string suffix, bool ignoreCase = false)
+            => str.EndsWith(suffix, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
+
+        public bool ContainsF(string subStr, bool ignoreCase = false)
+            => str.Contains(subStr, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
+
+        public int IndexOfF(string subStr, bool ignoreCase = false)
+            => str.IndexOf(subStr, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
+
+        public int IndexOfF(string subStr, int startIndex, bool ignoreCase = false)
+            => str.IndexOf(subStr, startIndex, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
+
+        public int LastIndexOfF(string subStr, bool ignoreCase = false)
+            => str.LastIndexOf(subStr, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
+
+        public int LastIndexOfF(string subStr, int startIndex, bool ignoreCase = false)
+            => str.LastIndexOf(subStr, startIndex, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
+    }
+
+    extension(string hex)
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public byte[] HexToBytes() => Convert.FromHexString(hex);
+    }
+}

launcher/PCL-CE/PCL.Core/Utils/Exts/TaskExtension.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace PCL.Core.Utils.Exts;
+public static class TaskExtensions
+{
+    /// <summary>
+    /// 返回第一个成功完成的 Task 的结果。
+    /// 如果所有 Task 都失败或被取消，则抛出 AggregateException。
+    /// </summary>
+    /// <typeparam name="T">Task 的返回类型</typeparam>
+    /// <param name="tasks">要等待的任务集合</param>
+    /// <returns>第一个成功完成的 Task 的结果</returns>
+    /// <exception cref="ArgumentException">任务集合为空</exception>
+    /// <exception cref="AggregateException">所有任务均未成功完成</exception>
+    public static async Task<Task<T>> WhenAnySuccessAsync<T>(this IEnumerable<Task<T>> tasks)
+    {
+        ArgumentNullException.ThrowIfNull(tasks, nameof(tasks));
+        var taskList = tasks.ToList();
+        if (taskList.Count == 0)
+            throw new ArgumentException("Task collection is empty.", nameof(tasks));
+
+        var remaining = new HashSet<Task<T>>(taskList);
+
+        while (remaining.Count > 0)
+        {
+            var completed = await Task.WhenAny(remaining);
+            remaining.Remove(completed);
+            if (completed.IsCompletedSuccessfully)
+            {
+                return completed;
+            }
+        }
+
+        // 所有任务都失败或被取消
+        var faultedExceptions = taskList
+            .Where(t => t.IsFaulted)
+            .SelectMany(t => t.Exception?.Flatten().InnerExceptions ?? Enumerable.Empty<Exception>())
+            .ToList();
+
+        if (faultedExceptions.Count > 0)
+        {
+            throw new AggregateException("All connection attempts failed.", faultedExceptions);
+        }
+
+        // 如果没有失败任务，但还有任务，为 canceled
+        if (taskList.Any(t => t.IsCanceled))
+        {
+            throw new OperationCanceledException("All connection attempts were canceled.");
+        }
+
+        // Task 要么成功，要么 Faulted，要么 Canceled，大概率走不到这
+        throw new InvalidOperationException("All tasks completed but none succeeded, failed, or canceled.");
+    }
+
+    extension(Task task)
+    {
+        /// <summary>
+        /// 不关心 Task 后续的异常，但是需要观察下
+        /// </summary>
+        public void Forget()
+        {
+            _ = task.ContinueWith(t => _ = t.Exception, TaskContinuationOptions.OnlyOnFaulted);
+        }
+    }
+}

launcher/PCL-CE/PCL.Core/Utils/Exts/UiExtension.cs

@@ -0,0 +1,57 @@
+namespace PCL.Core.Utils.Exts;
+
+using System;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+
+/// <summary>
+/// 提供 WPF UI 控件的扩展方法。
+/// </summary>
+public static class UiExtension {
+    /// <summary>
+    /// 检查控件是否在指定窗口的可视区域内，且控件本身可见。
+    /// </summary>
+    /// <param name="element">要检查的 FrameworkElement。</param>
+    /// <param name="mainWindow">主窗口，用于确定可视区域。</param>
+    /// <returns>如果控件部分或完全在窗口可视区域内且可见，则返回 true；否则返回 false。</returns>
+    /// <exception cref="ArgumentNullException">当 <paramref name="element"/> 或 <paramref name="mainWindow"/> 为 null 时抛出。</exception>
+    public static bool IsVisibleInWindow(this FrameworkElement element, Window mainWindow) {
+        if (!element.IsVisible) return false;
+
+        try {
+            var transform = element.TransformToAncestor(mainWindow);
+            var bounds = transform.TransformBounds(new Rect(0, 0, element.ActualWidth, element.ActualHeight));
+            var windowRect = new Rect(0, 0, mainWindow.ActualWidth, mainWindow.ActualHeight);
+            return windowRect.IntersectsWith(bounds);
+        } catch (InvalidOperationException) {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// 检查 TextBlock 是否因 TextTrimming 属性导致文本被截断。
+    /// </summary>
+    /// <param name="textBlock">要检查的 TextBlock。</param>
+    /// <returns>如果文本被截断，则返回 true；否则返回 false。</returns>
+    /// <exception cref="ArgumentNullException">当 <paramref name="textBlock"/> 为 null 时抛出。</exception>
+    public static bool IsTextTrimmed(this TextBlock textBlock) {
+        if (textBlock.TextTrimming == TextTrimming.None) return false;
+
+        try {
+            var formattedText = new FormattedText(
+                textBlock.Text,
+                System.Globalization.CultureInfo.CurrentCulture,
+                textBlock.FlowDirection,
+                new Typeface(textBlock.FontFamily, textBlock.FontStyle, textBlock.FontWeight, textBlock.FontStretch),
+                textBlock.FontSize,
+                textBlock.Foreground,
+                VisualTreeHelper.GetDpi(textBlock).PixelsPerDip
+                );
+
+            return formattedText.Width > textBlock.ActualWidth;
+        } catch (Exception) {
+            return false;
+        }
+    }
+}