- 引入 UnityGameFramework

- 使用 Luban 替代原来的 UGF 的数据表

Assets/GameMain/Scripts/Runtime/BuiltinComponent/AsyncTask/AsyncTaskHelper.cs

@@ -0,0 +1,127 @@
+using System;
+using System.Threading;
+using Cysharp.Threading.Tasks;
+using GameFramework.Event;
+
+namespace SepCore.AsyncTask
+{
+    /// <summary>
+    /// 异步任务辅助类，用于将事件回调转换为 UniTask
+    /// </summary>
+    public static class AsyncTaskHelper
+    {
+        /// <summary>
+        /// 等待指定事件触发
+        /// </summary>
+        /// <typeparam name="T">事件参数类型</typeparam>
+        /// <param name="eventId">事件ID</param>
+        /// <param name="predicate">事件过滤条件</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>事件参数</returns>
+        public static UniTask<T> WaitEventAsync<T>(int eventId, Func<T, bool> predicate = null, float timeout = 0f) where T : GameEventArgs
+        {
+            var tcs = new UniTaskCompletionSource<T>();
+            var eventComponent = global::GameEntry.Event;
+
+            EventHandler<GameEventArgs> handler = null;
+            handler = (_, e) =>
+            {
+                var args = e as T;
+                if (args == null) return;
+
+                if (predicate != null && !predicate(args)) return;
+
+                eventComponent.Unsubscribe(eventId, handler);
+                tcs.TrySetResult(args);
+            };
+
+            eventComponent.Subscribe(eventId, handler);
+
+            // 超时处理
+            if (timeout > 0f)
+            {
+                UniTask.Delay(TimeSpan.FromSeconds(timeout), cancellationToken: CancellationToken.None)
+                    .ContinueWith(() =>
+                    {
+                        if (tcs.TrySetException(new TimeoutException($"等待事件超时: {timeout}秒")))
+                        {
+                            eventComponent.Unsubscribe(eventId, handler);
+                        }
+                    });
+            }
+
+            return tcs.Task;
+        }
+
+        /// <summary>
+        /// 等待成功或失败事件
+        /// </summary>
+        /// <typeparam name="TSuccess">成功事件参数类型</typeparam>
+        /// <typeparam name="TFailure">失败事件参数类型</typeparam>
+        /// <param name="successEventId">成功事件ID</param>
+        /// <param name="failureEventId">失败事件ID</param>
+        /// <param name="successPredicate">成功事件过滤条件</param>
+        /// <param name="failurePredicate">失败事件过滤条件</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>成功事件参数</returns>
+        public static UniTask<TSuccess> WaitSuccessOrFailureAsync<TSuccess, TFailure>(
+            int successEventId,
+            int failureEventId,
+            Func<TSuccess, bool> successPredicate = null,
+            Func<TFailure, bool> failurePredicate = null,
+            float timeout = 0f)
+            where TSuccess : GameEventArgs
+            where TFailure : GameEventArgs
+        {
+            var tcs = new UniTaskCompletionSource<TSuccess>();
+            var eventComponent = global::GameEntry.Event;
+
+            // 先声明两个 handler，再赋值 lambda，避免前向引用
+            EventHandler<GameEventArgs> successHandler = null;
+            EventHandler<GameEventArgs> failureHandler = null;
+
+            successHandler = (_, e) =>
+            {
+                var args = e as TSuccess;
+                if (args == null) return;
+
+                if (successPredicate != null && !successPredicate(args)) return;
+
+                eventComponent.Unsubscribe(successEventId, successHandler);
+                eventComponent.Unsubscribe(failureEventId, failureHandler);
+                tcs.TrySetResult(args);
+            };
+
+            failureHandler = (_, e) =>
+            {
+                var args = e as TFailure;
+                if (args == null) return;
+
+                if (failurePredicate != null && !failurePredicate(args)) return;
+
+                eventComponent.Unsubscribe(successEventId, successHandler);
+                eventComponent.Unsubscribe(failureEventId, failureHandler);
+                tcs.TrySetException(new Exception($"操作失败: {args}"));
+            };
+
+            eventComponent.Subscribe(successEventId, successHandler);
+            eventComponent.Subscribe(failureEventId, failureHandler);
+
+            // 超时处理
+            if (timeout > 0f)
+            {
+                UniTask.Delay(TimeSpan.FromSeconds(timeout), cancellationToken: CancellationToken.None)
+                    .ContinueWith(() =>
+                    {
+                        if (tcs.TrySetException(new TimeoutException($"等待事件超时: {timeout}秒")))
+                        {
+                            eventComponent.Unsubscribe(successEventId, successHandler);
+                            eventComponent.Unsubscribe(failureEventId, failureHandler);
+                        }
+                    });
+            }
+
+            return tcs.Task;
+        }
+    }
+}

Assets/GameMain/Scripts/Runtime/BuiltinComponent/AsyncTask/AsyncTaskHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 32dddf8dedbcf384db9e3320cdc285ce
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GameMain/Scripts/Runtime/BuiltinComponent/AsyncTask/ConfigAsyncExtension.cs

@@ -0,0 +1,61 @@
+using Cysharp.Threading.Tasks;
+using UnityGameFramework.Runtime;
+
+namespace SepCore.AsyncTask
+{
+    /// <summary>
+    /// Config 异步扩展方法
+    /// </summary>
+    public static class ConfigAsyncExtension
+    {
+        /// <summary>
+        /// 异步加载配置
+        /// </summary>
+        /// <param name="configComponent">配置组件</param>
+        /// <param name="configAssetName">配置资源名称</param>
+        /// <param name="userData">用户自定义数据</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>加载成功事件</returns>
+        public static UniTask<LoadConfigSuccessEventArgs> LoadConfigAsync(this ConfigComponent configComponent,
+            string configAssetName,
+            object userData = null,
+            float timeout = 30f)
+        {
+            UniTask<LoadConfigSuccessEventArgs> waitTask = AsyncTaskHelper.WaitSuccessOrFailureAsync<LoadConfigSuccessEventArgs, LoadConfigFailureEventArgs>(
+                LoadConfigSuccessEventArgs.EventId,
+                LoadConfigFailureEventArgs.EventId,
+                successArgs => successArgs.ConfigAssetName == configAssetName && ReferenceEquals(successArgs.UserData, userData),
+                failureArgs => failureArgs.ConfigAssetName == configAssetName && ReferenceEquals(failureArgs.UserData, userData),
+                timeout
+            );
+
+            configComponent.ReadData(configAssetName, userData);
+            return waitTask;
+        }
+
+        /// <summary>
+        /// 异步加载配置（通过字典加载）
+        /// </summary>
+        /// <param name="configComponent">配置组件</param>
+        /// <param name="dictionaryName">字典名称</param>
+        /// <param name="userData">用户自定义数据</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>加载成功事件</returns>
+        public static UniTask<LoadConfigSuccessEventArgs> LoadConfigFromDictionaryAsync(this ConfigComponent configComponent,
+            string dictionaryName,
+            object userData = null,
+            float timeout = 30f)
+        {
+            UniTask<LoadConfigSuccessEventArgs> waitTask = AsyncTaskHelper.WaitSuccessOrFailureAsync<LoadConfigSuccessEventArgs, LoadConfigFailureEventArgs>(
+                LoadConfigSuccessEventArgs.EventId,
+                LoadConfigFailureEventArgs.EventId,
+                successArgs => successArgs.ConfigAssetName == dictionaryName && ReferenceEquals(successArgs.UserData, userData),
+                failureArgs => failureArgs.ConfigAssetName == dictionaryName && ReferenceEquals(failureArgs.UserData, userData),
+                timeout
+            );
+
+            configComponent.ReadData(dictionaryName, userData);
+            return waitTask;
+        }
+    }
+}

Assets/GameMain/Scripts/Runtime/BuiltinComponent/AsyncTask/ConfigAsyncExtension.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c268d17be2de9c242939823c820012e4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GameMain/Scripts/Runtime/BuiltinComponent/AsyncTask/DownloadAsyncExtension.cs

@@ -0,0 +1,59 @@
+using Cysharp.Threading.Tasks;
+using GameFramework.Download;
+using UnityGameFramework.Runtime;
+using DownloadFailureEventArgs = UnityGameFramework.Runtime.DownloadFailureEventArgs;
+using DownloadSuccessEventArgs = UnityGameFramework.Runtime.DownloadSuccessEventArgs;
+
+namespace SepCore.AsyncTask
+{
+    /// <summary>
+    /// Download 异步扩展方法
+    /// </summary>
+    public static class DownloadAsyncExtension
+    {
+        /// <summary>
+        /// 异步下载文件
+        /// </summary>
+        /// <param name="downloadComponent">下载组件</param>
+        /// <param name="downloadUri">下载地址</param>
+        /// <param name="downloadPath">下载后存放路径</param>
+        /// <param name="userData">用户自定义数据</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>下载成功事件</returns>
+        public static UniTask<DownloadSuccessEventArgs> DownloadFileAsync(this DownloadComponent downloadComponent,
+            string downloadUri,
+            string downloadPath,
+            object userData = null,
+            float timeout = 300f)
+        {
+            int serialId = 0;
+            UniTask<DownloadSuccessEventArgs> waitTask =
+                AsyncTaskHelper.WaitSuccessOrFailureAsync<DownloadSuccessEventArgs, DownloadFailureEventArgs>(
+                    DownloadSuccessEventArgs.EventId,
+                    DownloadFailureEventArgs.EventId,
+                    successArgs => successArgs.SerialId == serialId,
+                    failureArgs => failureArgs.SerialId == serialId,
+                    timeout
+                );
+
+            serialId = downloadComponent.AddDownload(downloadPath, downloadUri, userData);
+            return waitTask;
+        }
+
+        /// <summary>
+        /// 异步下载文件（简化版本）
+        /// </summary>
+        /// <param name="downloadComponent">下载组件</param>
+        /// <param name="downloadUri">下载地址</param>
+        /// <param name="downloadPath">下载后存放路径</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>下载成功事件</returns>
+        public static UniTask<DownloadSuccessEventArgs> DownloadFileAsync(this DownloadComponent downloadComponent,
+            string downloadUri,
+            string downloadPath,
+            float timeout = 300f)
+        {
+            return DownloadFileAsync(downloadComponent, downloadUri, downloadPath, null, timeout);
+        }
+    }
+}

Assets/GameMain/Scripts/Runtime/BuiltinComponent/AsyncTask/DownloadAsyncExtension.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cfc5e4ff432a8564a99f65529449b370
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GameMain/Scripts/Runtime/BuiltinComponent/AsyncTask/EntityAsyncExtension.cs

@@ -0,0 +1,118 @@
+using System;
+using Cysharp.Threading.Tasks;
+using GameFramework.Entity;
+using UnityGameFramework.Runtime;
+using HideEntityCompleteEventArgs = UnityGameFramework.Runtime.HideEntityCompleteEventArgs;
+using ShowEntityFailureEventArgs = UnityGameFramework.Runtime.ShowEntityFailureEventArgs;
+using ShowEntitySuccessEventArgs = UnityGameFramework.Runtime.ShowEntitySuccessEventArgs;
+
+namespace SepCore.AsyncTask
+{
+    /// <summary>
+    /// Entity 异步扩展方法
+    /// </summary>
+    public static class EntityAsyncExtension
+    {
+        /// <summary>
+        /// 异步显示实体
+        /// </summary>
+        /// <param name="entityComponent">实体组件</param>
+        /// <param name="entityId">实体编号</param>
+        /// <param name="entityLogicType">实体逻辑类型</param>
+        /// <param name="entityAssetName">实体资源名称</param>
+        /// <param name="entityGroupName">实体组名称</param>
+        /// <param name="userData">用户自定义数据</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>显示的实体</returns>
+        public static UniTask<UnityGameFramework.Runtime.Entity> ShowEntityAsync(this EntityComponent entityComponent,
+            int entityId,
+            Type entityLogicType,
+            string entityAssetName,
+            string entityGroupName,
+            object userData = null,
+            float timeout = 30f)
+        {
+            UniTask<UnityGameFramework.Runtime.Entity> waitTask = AsyncTaskHelper
+                .WaitSuccessOrFailureAsync<ShowEntitySuccessEventArgs, ShowEntityFailureEventArgs>(
+                    ShowEntitySuccessEventArgs.EventId,
+                    ShowEntityFailureEventArgs.EventId,
+                    successArgs => successArgs.Entity.Id == entityId && ReferenceEquals(successArgs.UserData, userData),
+                    failureArgs => failureArgs.EntityId == entityId && ReferenceEquals(failureArgs.UserData, userData),
+                    timeout
+                ).ContinueWith(successArgs => successArgs.Entity);
+
+            entityComponent.ShowEntity(entityId, entityLogicType, entityAssetName, entityGroupName, userData);
+            return waitTask;
+        }
+
+        /// <summary>
+        /// 异步显示实体（泛型版本）
+        /// </summary>
+        /// <typeparam name="T">实体逻辑类型</typeparam>
+        /// <param name="entityComponent">实体组件</param>
+        /// <param name="entityId">实体编号</param>
+        /// <param name="entityAssetName">实体资源名称</param>
+        /// <param name="entityGroupName">实体组名称</param>
+        /// <param name="userData">用户自定义数据</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>显示的实体</returns>
+        public static UniTask<T> ShowEntityAsync<T>(this EntityComponent entityComponent,
+            int entityId,
+            string entityAssetName,
+            string entityGroupName,
+            object userData = null,
+            float timeout = 30f) where T : EntityLogic
+        {
+            UniTask<T> waitTask = AsyncTaskHelper
+                .WaitSuccessOrFailureAsync<ShowEntitySuccessEventArgs, ShowEntityFailureEventArgs>(
+                    ShowEntitySuccessEventArgs.EventId,
+                    ShowEntityFailureEventArgs.EventId,
+                    successArgs => successArgs.Entity.Id == entityId && ReferenceEquals(successArgs.UserData, userData),
+                    failureArgs => failureArgs.EntityId == entityId && ReferenceEquals(failureArgs.UserData, userData),
+                    timeout
+                ).ContinueWith(successArgs => (T)successArgs.Entity.Logic);
+
+            entityComponent.ShowEntity<T>(entityId, entityAssetName, entityGroupName, userData);
+            return waitTask;
+        }
+
+        /// <summary>
+        /// 异步隐藏实体
+        /// </summary>
+        /// <param name="entityComponent">实体组件</param>
+        /// <param name="entityId">实体编号</param>
+        /// <param name="userData">用户自定义数据</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>隐藏完成事件</returns>
+        public static UniTask<HideEntityCompleteEventArgs> HideEntityAsync(this EntityComponent entityComponent,
+            int entityId,
+            object userData = null,
+            float timeout = 30f)
+        {
+            UniTask<HideEntityCompleteEventArgs> waitTask = AsyncTaskHelper.WaitEventAsync<HideEntityCompleteEventArgs>(
+                HideEntityCompleteEventArgs.EventId,
+                args => args.EntityId == entityId,
+                timeout
+            );
+
+            entityComponent.HideEntity(entityId, userData);
+            return waitTask;
+        }
+
+        /// <summary>
+        /// 异步隐藏实体（通过实体对象）
+        /// </summary>
+        /// <param name="entityComponent">实体组件</param>
+        /// <param name="entity">要隐藏的实体</param>
+        /// <param name="userData">用户自定义数据</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>隐藏完成事件</returns>
+        public static UniTask<HideEntityCompleteEventArgs> HideEntityAsync(this EntityComponent entityComponent,
+            UnityGameFramework.Runtime.Entity entity,
+            object userData = null,
+            float timeout = 30f)
+        {
+            return HideEntityAsync(entityComponent, entity.Id, userData, timeout);
+        }
+    }
+}

Assets/GameMain/Scripts/Runtime/BuiltinComponent/AsyncTask/EntityAsyncExtension.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0049c1a3ff0446246b18d6b2ab0f29c6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GameMain/Scripts/Runtime/BuiltinComponent/AsyncTask/LocalizationAsyncExtension.cs

@@ -0,0 +1,36 @@
+using Cysharp.Threading.Tasks;
+using UnityGameFramework.Runtime;
+
+namespace SepCore.AsyncTask
+{
+    /// <summary>
+    /// Localization 异步扩展方法
+    /// </summary>
+    public static class LocalizationAsyncExtension
+    {
+        /// <summary>
+        /// 异步加载字典
+        /// </summary>
+        /// <param name="localizationComponent">本地化组件</param>
+        /// <param name="dictionaryAssetName">字典资源名称</param>
+        /// <param name="userData">用户自定义数据</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>加载成功事件</returns>
+        public static UniTask<LoadDictionarySuccessEventArgs> LoadDictionaryAsync(this LocalizationComponent localizationComponent,
+            string dictionaryAssetName,
+            object userData = null,
+            float timeout = 30f)
+        {
+            UniTask<LoadDictionarySuccessEventArgs> waitTask = AsyncTaskHelper.WaitSuccessOrFailureAsync<LoadDictionarySuccessEventArgs, LoadDictionaryFailureEventArgs>(
+                LoadDictionarySuccessEventArgs.EventId,
+                LoadDictionaryFailureEventArgs.EventId,
+                successArgs => successArgs.DictionaryAssetName == dictionaryAssetName && ReferenceEquals(successArgs.UserData, userData),
+                failureArgs => failureArgs.DictionaryAssetName == dictionaryAssetName && ReferenceEquals(failureArgs.UserData, userData),
+                timeout
+            );
+
+            localizationComponent.ReadData(dictionaryAssetName, userData);
+            return waitTask;
+        }
+    }
+}

Assets/GameMain/Scripts/Runtime/BuiltinComponent/AsyncTask/LocalizationAsyncExtension.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2d8cd831d31f1e746bbc65c5591dc930
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GameMain/Scripts/Runtime/BuiltinComponent/AsyncTask/NetworkAsyncExtension.cs

@@ -0,0 +1,75 @@
+using Cysharp.Threading.Tasks;
+using UnityGameFramework.Runtime;
+using NetworkClosedEventArgs = UnityGameFramework.Runtime.NetworkClosedEventArgs;
+using NetworkConnectedEventArgs = UnityGameFramework.Runtime.NetworkConnectedEventArgs;
+
+namespace SepCore.AsyncTask
+{
+    /// <summary>
+    /// Network 异步扩展方法
+    /// </summary>
+    public static class NetworkAsyncExtension
+    {
+        /// <summary>
+        /// 异步连接网络
+        /// </summary>
+        /// <param name="networkComponent">网络组件</param>
+        /// <param name="networkChannelName">网络频道名称</param>
+        /// <param name="address">连接地址</param>
+        /// <param name="userData">用户自定义数据</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>连接成功事件</returns>
+        public static UniTask<NetworkConnectedEventArgs> ConnectAsync(this NetworkComponent networkComponent,
+            string networkChannelName,
+            string address,
+            object userData = null,
+            float timeout = 30f)
+        {
+            return AsyncTaskHelper.WaitEventAsync<NetworkConnectedEventArgs>(
+                NetworkConnectedEventArgs.EventId,
+                args => args.NetworkChannel.Name == networkChannelName,
+                timeout
+            );
+        }
+
+        /// <summary>
+        /// 异步连接网络（带端口）
+        /// </summary>
+        /// <param name="networkComponent">网络组件</param>
+        /// <param name="networkChannelName">网络频道名称</param>
+        /// <param name="address">连接地址</param>
+        /// <param name="port">端口号</param>
+        /// <param name="userData">用户自定义数据</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>连接成功事件</returns>
+        public static UniTask<NetworkConnectedEventArgs> ConnectAsync(this NetworkComponent networkComponent,
+            string networkChannelName,
+            string address,
+            int port,
+            object userData = null,
+            float timeout = 30f)
+        {
+            return ConnectAsync(networkComponent, networkChannelName, $"{address}:{port}", userData, timeout);
+        }
+
+        /// <summary>
+        /// 异步断开网络连接
+        /// </summary>
+        /// <param name="networkComponent">网络组件</param>
+        /// <param name="networkChannelName">网络频道名称</param>
+        /// <param name="userData">用户自定义数据</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>关闭事件</returns>
+        public static UniTask<NetworkClosedEventArgs> DisconnectAsync(this NetworkComponent networkComponent,
+            string networkChannelName,
+            object userData = null,
+            float timeout = 30f)
+        {
+            return AsyncTaskHelper.WaitEventAsync<NetworkClosedEventArgs>(
+                NetworkClosedEventArgs.EventId,
+                args => args.NetworkChannel.Name == networkChannelName,
+                timeout
+            );
+        }
+    }
+}

Assets/GameMain/Scripts/Runtime/BuiltinComponent/AsyncTask/NetworkAsyncExtension.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cc307b69189670d499c75d8c4cb5553a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GameMain/Scripts/Runtime/BuiltinComponent/AsyncTask/ResourceAsyncExtension.cs

@@ -0,0 +1,62 @@
+using Cysharp.Threading.Tasks;
+using UnityGameFramework.Runtime;
+using ResourceApplySuccessEventArgs = UnityGameFramework.Runtime.ResourceApplySuccessEventArgs;
+using ResourceUpdateAllCompleteEventArgs = UnityGameFramework.Runtime.ResourceUpdateAllCompleteEventArgs;
+using ResourceVerifySuccessEventArgs = UnityGameFramework.Runtime.ResourceVerifySuccessEventArgs;
+
+namespace SepCore.AsyncTask
+{
+    /// <summary>
+    /// Resource 异步扩展方法
+    /// </summary>
+    public static class ResourceAsyncExtension
+    {
+        /// <summary>
+        /// 异步等待资源更新完成
+        /// </summary>
+        /// <param name="resourceComponent">资源组件</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>更新完成事件</returns>
+        public static UniTask<ResourceUpdateAllCompleteEventArgs> WaitForResourceUpdateCompleteAsync(this ResourceComponent resourceComponent,
+            float timeout = 0f)
+        {
+            return AsyncTaskHelper.WaitEventAsync<ResourceUpdateAllCompleteEventArgs>(
+                ResourceUpdateAllCompleteEventArgs.EventId,
+                null,
+                timeout
+            );
+        }
+
+        /// <summary>
+        /// 异步等待资源验证完成
+        /// </summary>
+        /// <param name="resourceComponent">资源组件</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>验证成功事件</returns>
+        public static UniTask<ResourceVerifySuccessEventArgs> WaitForResourceVerifyCompleteAsync(this ResourceComponent resourceComponent,
+            float timeout = 0f)
+        {
+            return AsyncTaskHelper.WaitEventAsync<ResourceVerifySuccessEventArgs>(
+                ResourceVerifySuccessEventArgs.EventId,
+                null,
+                timeout
+            );
+        }
+
+        /// <summary>
+        /// 异步等待资源应用完成
+        /// </summary>
+        /// <param name="resourceComponent">资源组件</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>应用成功事件</returns>
+        public static UniTask<ResourceApplySuccessEventArgs> WaitForResourceApplyCompleteAsync(this ResourceComponent resourceComponent,
+            float timeout = 0f)
+        {
+            return AsyncTaskHelper.WaitEventAsync<ResourceApplySuccessEventArgs>(
+                ResourceApplySuccessEventArgs.EventId,
+                null,
+                timeout
+            );
+        }
+    }
+}

Assets/GameMain/Scripts/Runtime/BuiltinComponent/AsyncTask/ResourceAsyncExtension.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e1e5440eb71427c42a16164ab6a664e2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GameMain/Scripts/Runtime/BuiltinComponent/AsyncTask/SceneAsyncExtension.cs

@@ -0,0 +1,66 @@
+using Cysharp.Threading.Tasks;
+using GameFramework.Scene;
+using UnityGameFramework.Runtime;
+using LoadSceneFailureEventArgs = UnityGameFramework.Runtime.LoadSceneFailureEventArgs;
+using LoadSceneSuccessEventArgs = UnityGameFramework.Runtime.LoadSceneSuccessEventArgs;
+using UnloadSceneFailureEventArgs = UnityGameFramework.Runtime.UnloadSceneFailureEventArgs;
+using UnloadSceneSuccessEventArgs = UnityGameFramework.Runtime.UnloadSceneSuccessEventArgs;
+
+namespace SepCore.AsyncTask
+{
+    /// <summary>
+    /// Scene 异步扩展方法
+    /// </summary>
+    public static class SceneAsyncExtension
+    {
+        /// <summary>
+        /// 异步加载场景
+        /// </summary>
+        /// <param name="sceneComponent">场景组件</param>
+        /// <param name="sceneAssetName">场景资源名称</param>
+        /// <param name="userData">用户自定义数据</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>加载成功事件</returns>
+        public static UniTask<LoadSceneSuccessEventArgs> LoadSceneAsync(this SceneComponent sceneComponent,
+            string sceneAssetName,
+            object userData = null,
+            float timeout = 60f)
+        {
+            UniTask<LoadSceneSuccessEventArgs> waitTask = AsyncTaskHelper.WaitSuccessOrFailureAsync<LoadSceneSuccessEventArgs, LoadSceneFailureEventArgs>(
+                LoadSceneSuccessEventArgs.EventId,
+                LoadSceneFailureEventArgs.EventId,
+                successArgs => successArgs.SceneAssetName == sceneAssetName && ReferenceEquals(successArgs.UserData, userData),
+                failureArgs => failureArgs.SceneAssetName == sceneAssetName && ReferenceEquals(failureArgs.UserData, userData),
+                timeout
+            );
+
+            sceneComponent.LoadScene(sceneAssetName, userData);
+            return waitTask;
+        }
+
+        /// <summary>
+        /// 异步卸载场景
+        /// </summary>
+        /// <param name="sceneComponent">场景组件</param>
+        /// <param name="sceneAssetName">场景资源名称</param>
+        /// <param name="userData">用户自定义数据</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>卸载成功事件</returns>
+        public static UniTask<UnloadSceneSuccessEventArgs> UnloadSceneAsync(this SceneComponent sceneComponent,
+            string sceneAssetName,
+            object userData = null,
+            float timeout = 60f)
+        {
+            UniTask<UnloadSceneSuccessEventArgs> waitTask = AsyncTaskHelper.WaitSuccessOrFailureAsync<UnloadSceneSuccessEventArgs, UnloadSceneFailureEventArgs>(
+                UnloadSceneSuccessEventArgs.EventId,
+                UnloadSceneFailureEventArgs.EventId,
+                successArgs => successArgs.SceneAssetName == sceneAssetName && ReferenceEquals(successArgs.UserData, userData),
+                failureArgs => failureArgs.SceneAssetName == sceneAssetName && ReferenceEquals(failureArgs.UserData, userData),
+                timeout
+            );
+
+            sceneComponent.UnloadScene(sceneAssetName, userData);
+            return waitTask;
+        }
+    }
+}

Assets/GameMain/Scripts/Runtime/BuiltinComponent/AsyncTask/SceneAsyncExtension.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b140d86ecd745fd48b99bdc70b28b6e1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GameMain/Scripts/Runtime/BuiltinComponent/AsyncTask/SoundAsyncExtension.cs

@@ -0,0 +1,45 @@
+using Cysharp.Threading.Tasks;
+using GameFramework.Sound;
+using UnityGameFramework.Runtime;
+using PlaySoundFailureEventArgs = UnityGameFramework.Runtime.PlaySoundFailureEventArgs;
+using PlaySoundSuccessEventArgs = UnityGameFramework.Runtime.PlaySoundSuccessEventArgs;
+
+namespace SepCore.AsyncTask
+{
+    /// <summary>
+    /// Sound 异步扩展方法
+    /// </summary>
+    public static class SoundAsyncExtension
+    {
+        /// <summary>
+        /// 异步播放声音
+        /// </summary>
+        /// <param name="soundComponent">声音组件</param>
+        /// <param name="soundAssetName">声音资源名称</param>
+        /// <param name="soundGroupName">声音组名称</param>
+        /// <param name="playSoundParams">播放声音参数</param>
+        /// <param name="userData">用户自定义数据</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>播放成功事件</returns>
+        public static UniTask<PlaySoundSuccessEventArgs> PlaySoundAsync(this SoundComponent soundComponent,
+            string soundAssetName,
+            string soundGroupName,
+            PlaySoundParams playSoundParams = null,
+            object userData = null,
+            float timeout = 30f)
+        {
+            int serialId = 0;
+            UniTask<PlaySoundSuccessEventArgs> waitTask = AsyncTaskHelper.WaitSuccessOrFailureAsync<PlaySoundSuccessEventArgs, PlaySoundFailureEventArgs>(
+                PlaySoundSuccessEventArgs.EventId,
+                PlaySoundFailureEventArgs.EventId,
+                successArgs => successArgs.SerialId == serialId,
+                failureArgs => failureArgs.SerialId == serialId,
+                timeout
+            );
+
+            serialId = soundComponent.PlaySound(soundAssetName, soundGroupName, 0, playSoundParams, userData);
+            return waitTask;
+        }
+
+    }
+}

Assets/GameMain/Scripts/Runtime/BuiltinComponent/AsyncTask/SoundAsyncExtension.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cfb0decbe226b9d4895ed53603d37c29
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GameMain/Scripts/Runtime/BuiltinComponent/AsyncTask/UIAsyncExtension.cs

@@ -0,0 +1,124 @@
+using Cysharp.Threading.Tasks;
+using SepCore.UI;
+using UnityGameFramework.Runtime;
+using SepCore.Definition;
+
+namespace SepCore.AsyncTask
+{
+    /// <summary>
+    /// UI 异步扩展方法
+    /// </summary>
+    public static class UIAsyncExtension
+    {
+        /// <summary>
+        /// 等待界面打开完成
+        /// </summary>
+        /// <param name="uiComponent">UI组件</param>
+        /// <param name="serialId">界面序列编号</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>打开的界面</returns>
+        public static UniTask<UIForm> WaitOpenUIFormAsync(this UIComponent uiComponent,
+            int serialId,
+            float timeout = 30f)
+        {
+            return AsyncTaskHelper.WaitSuccessOrFailureAsync<OpenUIFormSuccessEventArgs, OpenUIFormFailureEventArgs>(
+                OpenUIFormSuccessEventArgs.EventId,
+                OpenUIFormFailureEventArgs.EventId,
+                successArgs => successArgs.UIForm.SerialId == serialId,
+                failureArgs => failureArgs.SerialId == serialId,
+                timeout
+            ).ContinueWith(successArgs => successArgs.UIForm);
+        }
+
+        /// <summary>
+        /// 异步打开界面
+        /// </summary>
+        /// <param name="uiComponent">UI组件</param>
+        /// <param name="uiFormAssetName">界面资源名称</param>
+        /// <param name="uiGroupName">界面组名称</param>
+        /// <param name="pauseCoveredUIForm">是否暂停被覆盖的界面</param>
+        /// <param name="userData">用户自定义数据</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>打开的界面</returns>
+        public static UniTask<UIForm> OpenUIFormAsync(this UIComponent uiComponent,
+            string uiFormAssetName,
+            string uiGroupName,
+            bool pauseCoveredUIForm = true,
+            object userData = null,
+            float timeout = 30f)
+        {
+            int serialId = 0;
+            UniTask<UIForm> waitTask = AsyncTaskHelper.WaitSuccessOrFailureAsync<OpenUIFormSuccessEventArgs, OpenUIFormFailureEventArgs>(
+                OpenUIFormSuccessEventArgs.EventId,
+                OpenUIFormFailureEventArgs.EventId,
+                successArgs => successArgs.UIForm.SerialId == serialId,
+                failureArgs => failureArgs.SerialId == serialId,
+                timeout
+            ).ContinueWith(successArgs => successArgs.UIForm);
+
+            serialId = uiComponent.OpenUIForm(uiFormAssetName, uiGroupName, pauseCoveredUIForm, userData);
+            return waitTask;
+        }
+
+        /// <summary>
+        /// 异步打开界面（通过界面编号）
+        /// </summary>
+        /// <param name="uiComponent">UI组件</param>
+        /// <param name="uiType">界面编号</param>
+        /// <param name="userData">用户自定义数据</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>打开的界面</returns>
+        public static UniTask<UIForm> OpenUIFormAsync(this UIComponent uiComponent,
+            UIFormType uiType,
+            object userData = null,
+            float timeout = 30f)
+        {
+            int? serialId = uiComponent.OpenUIForm(uiType, userData);
+            if (!serialId.HasValue)
+            {
+                return UniTask.FromResult<UIForm>(null);
+            }
+
+            return uiComponent.WaitOpenUIFormAsync(serialId.Value, timeout);
+        }
+
+        /// <summary>
+        /// 异步关闭界面
+        /// </summary>
+        /// <param name="uiComponent">UI组件</param>
+        /// <param name="serialId">界面序列编号</param>
+        /// <param name="userData">用户自定义数据</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>关闭完成事件</returns>
+        public static UniTask<CloseUIFormCompleteEventArgs> CloseUIFormAsync(this UIComponent uiComponent,
+            int serialId,
+            object userData = null,
+            float timeout = 30f)
+        {
+            UniTask<CloseUIFormCompleteEventArgs> waitTask = AsyncTaskHelper.WaitEventAsync<CloseUIFormCompleteEventArgs>(
+                CloseUIFormCompleteEventArgs.EventId,
+                args => args.SerialId == serialId,
+                timeout
+            );
+
+            uiComponent.CloseUIForm(serialId, userData);
+            return waitTask;
+        }
+
+        /// <summary>
+        /// 异步关闭界面（通过界面对象）
+        /// </summary>
+        /// <param name="uiComponent">UI组件</param>
+        /// <param name="uiForm">要关闭的界面</param>
+        /// <param name="userData">用户自定义数据</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>关闭完成事件</returns>
+        public static UniTask<CloseUIFormCompleteEventArgs> CloseUIFormAsync(this UIComponent uiComponent,
+            UIForm uiForm,
+            object userData = null,
+            float timeout = 30f)
+        {
+            return CloseUIFormAsync(uiComponent, uiForm.SerialId, userData, timeout);
+        }
+    }
+}

Assets/GameMain/Scripts/Runtime/BuiltinComponent/AsyncTask/UIAsyncExtension.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9ceba48ef9e814a40a88f96bf1fbf14c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GameMain/Scripts/Runtime/BuiltinComponent/AsyncTask/WebRequestAsyncExtension.cs

@@ -0,0 +1,101 @@
+using Cysharp.Threading.Tasks;
+using UnityGameFramework.Runtime;
+using WebRequestFailureEventArgs = UnityGameFramework.Runtime.WebRequestFailureEventArgs;
+using WebRequestSuccessEventArgs = UnityGameFramework.Runtime.WebRequestSuccessEventArgs;
+
+namespace SepCore.AsyncTask
+{
+    /// <summary>
+    /// WebRequest 异步扩展方法
+    /// </summary>
+    public static class WebRequestAsyncExtension
+    {
+        /// <summary>
+        /// 异步发送Web请求
+        /// </summary>
+        /// <param name="webRequestComponent">WebRequest组件</param>
+        /// <param name="webRequestUri">请求地址</param>
+        /// <param name="userData">用户自定义数据</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>请求成功事件</returns>
+        public static UniTask<WebRequestSuccessEventArgs> GetWebRequestAsync(this WebRequestComponent webRequestComponent,
+            string webRequestUri,
+            object userData = null,
+            float timeout = 30f)
+        {
+            int serialId = 0;
+            UniTask<WebRequestSuccessEventArgs> waitTask = AsyncTaskHelper.WaitSuccessOrFailureAsync<WebRequestSuccessEventArgs, WebRequestFailureEventArgs>(
+                WebRequestSuccessEventArgs.EventId,
+                WebRequestFailureEventArgs.EventId,
+                successArgs => successArgs.SerialId == serialId,
+                failureArgs => failureArgs.SerialId == serialId,
+                timeout
+            );
+
+            serialId = webRequestComponent.AddWebRequest(webRequestUri, userData);
+            return waitTask;
+        }
+
+        /// <summary>
+        /// 异步发送Web请求并获取字节数据
+        /// </summary>
+        /// <param name="webRequestComponent">WebRequest组件</param>
+        /// <param name="webRequestUri">请求地址</param>
+        /// <param name="userData">用户自定义数据</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>响应字节数据</returns>
+        public static UniTask<byte[]> GetWebRequestBytesAsync(this WebRequestComponent webRequestComponent,
+            string webRequestUri,
+            object userData = null,
+            float timeout = 30f)
+        {
+            return GetWebRequestAsync(webRequestComponent, webRequestUri, userData, timeout)
+                .ContinueWith(successArgs => successArgs.GetWebResponseBytes());
+        }
+
+        /// <summary>
+        /// 异步发送Web请求并获取字符串数据
+        /// </summary>
+        /// <param name="webRequestComponent">WebRequest组件</param>
+        /// <param name="webRequestUri">请求地址</param>
+        /// <param name="userData">用户自定义数据</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>响应字符串数据</returns>
+        public static UniTask<string> GetWebRequestStringAsync(this WebRequestComponent webRequestComponent,
+            string webRequestUri,
+            object userData = null,
+            float timeout = 30f)
+        {
+            return GetWebRequestBytesAsync(webRequestComponent, webRequestUri, userData, timeout)
+                .ContinueWith(bytes => System.Text.Encoding.UTF8.GetString(bytes));
+        }
+
+        /// <summary>
+        /// 异步发送POST请求
+        /// </summary>
+        /// <param name="webRequestComponent">WebRequest组件</param>
+        /// <param name="webRequestUri">请求地址</param>
+        /// <param name="postData">POST数据</param>
+        /// <param name="userData">用户自定义数据</param>
+        /// <param name="timeout">超时时间（秒），0表示不超时</param>
+        /// <returns>请求成功事件</returns>
+        public static UniTask<WebRequestSuccessEventArgs> PostWebRequestAsync(this WebRequestComponent webRequestComponent,
+            string webRequestUri,
+            byte[] postData,
+            object userData = null,
+            float timeout = 30f)
+        {
+            int serialId = 0;
+            UniTask<WebRequestSuccessEventArgs> waitTask = AsyncTaskHelper.WaitSuccessOrFailureAsync<WebRequestSuccessEventArgs, WebRequestFailureEventArgs>(
+                WebRequestSuccessEventArgs.EventId,
+                WebRequestFailureEventArgs.EventId,
+                successArgs => successArgs.SerialId == serialId,
+                failureArgs => failureArgs.SerialId == serialId,
+                timeout
+            );
+
+            serialId = webRequestComponent.AddWebRequest(webRequestUri, postData, userData);
+            return waitTask;
+        }
+    }
+}

Assets/GameMain/Scripts/Runtime/BuiltinComponent/AsyncTask/WebRequestAsyncExtension.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 579cf8ed8a820d34d9e7e46f60a3f176
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: