[+] TEngineServer

2025-08-14 16:51:28 +00:00 · 2023-07-13 17:17:26 +08:00
parent a69f53592e
commit 0c8f3a5f92
790 changed files with 52737 additions and 2533 deletions
--- a/Assets/GameScripts/DotNet/Core/Task/Builder.meta
+++ b/Assets/GameScripts/DotNet/Core/Task/Builder.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 00f992eda26fe684e8b9d529843d2a25
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/GameScripts/DotNet/Core/Task/Builder/AsyncFTaskCompletedMethodBuilder.cs
+++ b/Assets/GameScripts/DotNet/Core/Task/Builder/AsyncFTaskCompletedMethodBuilder.cs
@@ -0,0 +1,68 @@
+using System;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.ExceptionServices;
+using System.Runtime.InteropServices;
+using System.Security;
+
+namespace TEngine
+{
+    [StructLayout(LayoutKind.Auto)]
+    public struct AsyncFTaskCompletedMethodBuilder
+    {
+        // 1. Static Create method.
+        [DebuggerHidden]
+        public static AsyncFTaskCompletedMethodBuilder Create()
+        {
+            return new AsyncFTaskCompletedMethodBuilder();
+        }
+
+        // 2. TaskLike Task property(void)
+        public FTaskCompleted Task => default;
+
+        // 3. SetException
+        [DebuggerHidden]
+        public void SetException(Exception exception)
+        {
+            Log.Error(exception);
+            // ExceptionDispatchInfo.Capture(exception).Throw();
+        }
+
+        // 4. SetResult
+        [DebuggerHidden]
+        public void SetResult()
+        {
+        }
+
+        // 5. AwaitOnCompleted
+        [DebuggerHidden]
+        public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
+            where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
+        {
+            awaiter.OnCompleted(stateMachine.MoveNext);
+        }
+
+        // 6. AwaitUnsafeOnCompleted
+        [DebuggerHidden]
+        [SecuritySafeCritical]
+        public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter,
+            ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion
+            where TStateMachine : IAsyncStateMachine
+        {
+            awaiter.UnsafeOnCompleted(stateMachine.MoveNext);
+        }
+
+        // 7. Start
+        [DebuggerHidden]
+        public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
+        {
+            stateMachine.MoveNext();
+        }
+
+        // 8. SetStateMachine
+        [DebuggerHidden]
+        public void SetStateMachine(IAsyncStateMachine stateMachine)
+        {
+        }
+    }
+}
--- a/Assets/GameScripts/DotNet/Core/Task/Builder/AsyncFTaskCompletedMethodBuilder.cs.meta
+++ b/Assets/GameScripts/DotNet/Core/Task/Builder/AsyncFTaskCompletedMethodBuilder.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d9e4e2f1fe1bb0d42be6152751f563ff
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/GameScripts/DotNet/Core/Task/Builder/AsyncFTaskMethodBuilder.cs
+++ b/Assets/GameScripts/DotNet/Core/Task/Builder/AsyncFTaskMethodBuilder.cs
@@ -0,0 +1,151 @@
+using System;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace TEngine
+{
+    [StructLayout(LayoutKind.Auto)]
+    public readonly struct AsyncFTaskMethodBuilder
+    {
+        // 1. Static Create method.
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AsyncFTaskMethodBuilder Create()
+        {
+            return new AsyncFTaskMethodBuilder(FTask.Create());
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private AsyncFTaskMethodBuilder(FTask fTask)
+        {
+            Task = fTask;
+        }
+
+        // 4. Return to task
+        public FTask Task
+        {
+            [DebuggerHidden]
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get;
+        }
+
+        // 2. Start
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
+        {
+            stateMachine.MoveNext();
+        }
+
+        // 3. SetResult
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetResult()
+        {
+            Task.SetResult();
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetException(Exception exception)
+        {
+            Task.SetException(exception);
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
+            where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
+        {
+            awaiter.OnCompleted(stateMachine.MoveNext);
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter,
+            ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion
+            where TStateMachine : IAsyncStateMachine
+        {
+            awaiter.UnsafeOnCompleted(stateMachine.MoveNext);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetStateMachine(IAsyncStateMachine stateMachine)
+        {
+        }
+    }
+
+    [StructLayout(LayoutKind.Auto)]
+    public readonly struct AsyncFTaskMethodBuilder<T>
+    {
+        // 1. Static Create method.
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AsyncFTaskMethodBuilder<T> Create()
+        {
+            return new AsyncFTaskMethodBuilder<T>(FTask<T>.Create());
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private AsyncFTaskMethodBuilder(FTask<T> fTask)
+        {
+            Task = fTask;
+        }
+
+        // 4. Return to task
+        public FTask<T> Task
+        {
+            [DebuggerHidden]
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get;
+        }
+
+        // 2. Start
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
+        {
+            stateMachine.MoveNext();
+        }
+
+        // 3. SetResult
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetResult(T value)
+        {
+            Task.SetResult(value);
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetException(Exception exception)
+        {
+            Task.SetException(exception);
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
+            where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
+        {
+            awaiter.OnCompleted(stateMachine.MoveNext);
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter,
+            ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion
+            where TStateMachine : IAsyncStateMachine
+        {
+            awaiter.UnsafeOnCompleted(stateMachine.MoveNext);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetStateMachine(IAsyncStateMachine stateMachine)
+        {
+        }
+    }
+}
--- a/Assets/GameScripts/DotNet/Core/Task/Builder/AsyncFTaskMethodBuilder.cs.meta
+++ b/Assets/GameScripts/DotNet/Core/Task/Builder/AsyncFTaskMethodBuilder.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b8973ac6e4512594b9787095beaa62c6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/GameScripts/DotNet/Core/Task/Builder/AsyncFVoidMethodBuilder.cs
+++ b/Assets/GameScripts/DotNet/Core/Task/Builder/AsyncFVoidMethodBuilder.cs
@@ -0,0 +1,72 @@
+using System;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.ExceptionServices;
+using System.Runtime.InteropServices;
+
+namespace TEngine
+{
+    [StructLayout(LayoutKind.Auto)]
+    internal struct AsyncFVoidMethodBuilder
+    {
+        // 1. Static Create method.
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AsyncFVoidMethodBuilder Create()
+        {
+            return default;
+        }
+
+        // 2. Start
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
+        {
+            stateMachine.MoveNext();
+        }
+
+        // 3. SetResult
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetResult()
+        {
+        }
+
+        // 4. Return to task
+        public FVoid Task
+        {
+            [DebuggerHidden]
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => default;
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetException(Exception exception)
+        {
+            ExceptionDispatchInfo.Capture(exception).Throw();
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
+            where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
+        {
+            awaiter.OnCompleted(stateMachine.MoveNext);
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter,
+            ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion
+            where TStateMachine : IAsyncStateMachine
+        {
+            awaiter.UnsafeOnCompleted(stateMachine.MoveNext);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetStateMachine(IAsyncStateMachine stateMachine)
+        {
+        }
+    }
+}
--- a/Assets/GameScripts/DotNet/Core/Task/Builder/AsyncFVoidMethodBuilder.cs.meta
+++ b/Assets/GameScripts/DotNet/Core/Task/Builder/AsyncFVoidMethodBuilder.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 97a3c8247dd2a854485df3f751feb710
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/GameScripts/DotNet/Core/Task/FCancellationToken.cs
+++ b/Assets/GameScripts/DotNet/Core/Task/FCancellationToken.cs
@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+
+#pragma warning disable CS8625
+namespace TEngine
+{
+    public sealed class FCancellationToken
+    {
+        private HashSet<Action> _actions = new HashSet<Action>();
+        public bool IsCancel => _actions == null;
+    
+        public void Add(Action action)
+        {
+            _actions.Add(action);
+        }
+    
+        public void Remove(Action action)
+        {
+            _actions.Remove(action);
+        }
+    
+        public void Cancel()
+        {
+            if (_actions == null)
+            {
+                return;
+            }
+            
+            var runActions = _actions;
+            _actions = null;
+            
+            foreach (var action in runActions)
+            {
+                try
+                {
+                    action.Invoke();
+                }
+                catch (Exception e)
+                {
+                    Log.Error(e);
+                }
+            }
+        }
+    }
+}
+
--- a/Assets/GameScripts/DotNet/Core/Task/FCancellationToken.cs.meta
+++ b/Assets/GameScripts/DotNet/Core/Task/FCancellationToken.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 619ea7efe37fc984ea5b11c2e3400e9b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/GameScripts/DotNet/Core/Task/FTask.cs
+++ b/Assets/GameScripts/DotNet/Core/Task/FTask.cs
@@ -0,0 +1,299 @@
+using System;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.ExceptionServices;
+#pragma warning disable CS8601
+#pragma warning disable CS8603
+#pragma warning disable CS8625
+#pragma warning disable CS8618
+
+namespace TEngine
+{
+    public enum STaskStatus : byte
+    {
+        /// <summary>The operation has not yet completed.</summary>
+        Pending = 0,
+
+        /// <summary>The operation completed successfully.</summary>
+        Succeeded = 1,
+
+        /// <summary>The operation completed with an error.</summary>
+        Faulted = 2
+    }
+
+    [AsyncMethodBuilder(typeof(AsyncFTaskMethodBuilder))]
+    public sealed partial class FTask : ICriticalNotifyCompletion
+    {
+        private Action _callBack;
+        private ExceptionDispatchInfo _exception;
+        private bool _isFromPool;
+        private STaskStatus _status;
+
+        public bool IsCompleted
+        {
+            [DebuggerHidden]
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => _status != STaskStatus.Pending;
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void OnCompleted(Action continuation)
+        {
+            UnsafeOnCompleted(continuation);
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public FTask GetAwaiter()
+        {
+            return this;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [DebuggerHidden]
+        private async FVoid InnerCoroutine()
+        {
+            await this;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [DebuggerHidden]
+        public void Coroutine()
+        {
+            InnerCoroutine().Coroutine();
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetResult()
+        {
+            switch (_status)
+            {
+                case STaskStatus.Succeeded:
+                {
+                    Recycle();
+                    break;
+                }
+                case STaskStatus.Faulted:
+                {
+                    Recycle();
+                    
+                    if (_exception != null)
+                    {
+                        var exception = _exception;
+                        _exception = null;
+                        exception.Throw();
+                    }
+
+                    break;
+                }
+                default:
+                    throw new NotSupportedException("Direct call to getResult is not allowed");
+            }
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void Recycle()
+        {
+            if (!_isFromPool)
+            {
+                return;
+            }
+
+            _status = STaskStatus.Pending;
+            _callBack = null;
+            Pool<FTask>.Return(this);
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetResult()
+        {
+            if (_status != STaskStatus.Pending)
+            {
+                throw new InvalidOperationException("The task has been completed");
+            }
+
+            _status = STaskStatus.Succeeded;
+
+            if (_callBack == null)
+            {
+                return;
+            }
+
+            var callBack = _callBack;
+            _callBack = null;
+            callBack.Invoke();
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void UnsafeOnCompleted(Action continuation)
+        {
+            if (_status != STaskStatus.Pending)
+            {
+                continuation?.Invoke();
+                return;
+            }
+
+            _callBack = continuation;
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetException(Exception exception)
+        {
+            if (_status != STaskStatus.Pending)
+            {
+                throw new InvalidOperationException("The task has been completed");
+            }
+
+            _status = STaskStatus.Faulted;
+            _exception = ExceptionDispatchInfo.Capture(exception);
+            _callBack?.Invoke();
+        }
+    }
+
+    [AsyncMethodBuilder(typeof(AsyncFTaskMethodBuilder<>))]
+    public sealed partial class FTask<T> : ICriticalNotifyCompletion
+    {
+        private Action _callBack;
+        private ExceptionDispatchInfo _exception;
+        private bool _isFromPool;
+        private STaskStatus _status;
+        private T _value;
+
+        public bool IsCompleted
+        {
+            [DebuggerHidden]
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => _status != STaskStatus.Pending;
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void OnCompleted(Action continuation)
+        {
+            UnsafeOnCompleted(continuation);
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public FTask<T> GetAwaiter()
+        {
+            return this;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [DebuggerHidden]
+        private async FVoid InnerCoroutine()
+        {
+            await this;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [DebuggerHidden]
+        public void Coroutine()
+        {
+            InnerCoroutine().Coroutine();
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public T GetResult()
+        {
+            switch (_status)
+            {
+                case STaskStatus.Succeeded:
+                {
+                    var value = _value;
+                    Recycle();
+                    return value;
+                }
+                case STaskStatus.Faulted:
+                {
+                    Recycle();
+                    
+                    if (_exception == null)
+                    {
+                        return default;
+                    }
+
+                    var exception = _exception;
+                    _exception = null;
+                    exception.Throw();
+                    return default;
+                }
+                default:
+                    throw new NotSupportedException("Direct call to getResult is not allowed");
+            }
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void Recycle()
+        {
+            if (!_isFromPool)
+            {
+                return;
+            }
+
+            _status = STaskStatus.Pending;
+            _callBack = null;
+            _value = default;
+            Pool<FTask<T>>.Return(this);
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetResult(T value)
+        {
+            if (_status != STaskStatus.Pending)
+            {
+                throw new InvalidOperationException("The task has been completed");
+            }
+
+            _value = value;
+            _status = STaskStatus.Succeeded;
+
+            if (_callBack == null)
+            {
+                return;
+            }
+
+            var callBack = _callBack;
+            _callBack = null;
+            callBack.Invoke();
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void UnsafeOnCompleted(Action continuation)
+        {
+            if (_status != STaskStatus.Pending)
+            {
+                continuation?.Invoke();
+                return;
+            }
+
+            _callBack = continuation;
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetException(Exception exception)
+        {
+            if (_status != STaskStatus.Pending)
+            {
+                throw new InvalidOperationException("The task has been completed");
+            }
+
+            _status = STaskStatus.Faulted;
+            _exception = ExceptionDispatchInfo.Capture(exception);
+            _callBack?.Invoke();
+        }
+    }
+}
+
--- a/Assets/GameScripts/DotNet/Core/Task/FTask.cs.meta
+++ b/Assets/GameScripts/DotNet/Core/Task/FTask.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a4bfba30d0ddf4d4fb0da92631ce965b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/GameScripts/DotNet/Core/Task/FTaskCompleted.cs
+++ b/Assets/GameScripts/DotNet/Core/Task/FTaskCompleted.cs
@@ -0,0 +1,35 @@
+using System;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace TEngine
+{
+    [AsyncMethodBuilder(typeof(AsyncFTaskCompletedMethodBuilder))]
+    [StructLayout(LayoutKind.Auto)]
+    public struct FTaskCompleted : INotifyCompletion
+    {
+        [DebuggerHidden]
+        public FTaskCompleted GetAwaiter()
+        {
+            return this;
+        }
+
+        [DebuggerHidden] public bool IsCompleted => true;
+
+        [DebuggerHidden]
+        public void GetResult()
+        {
+        }
+
+        [DebuggerHidden]
+        public void OnCompleted(Action continuation)
+        {
+        }
+
+        [DebuggerHidden]
+        public void UnsafeOnCompleted(Action continuation)
+        {
+        }
+    }
+}
--- a/Assets/GameScripts/DotNet/Core/Task/FTaskCompleted.cs.meta
+++ b/Assets/GameScripts/DotNet/Core/Task/FTaskCompleted.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5bebfd7b883cd6b41892cf411a3532fd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/GameScripts/DotNet/Core/Task/FVoid.cs
+++ b/Assets/GameScripts/DotNet/Core/Task/FVoid.cs
@@ -0,0 +1,30 @@
+using System;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace TEngine
+{
+    [AsyncMethodBuilder(typeof(AsyncFVoidMethodBuilder))]
+    [StructLayout(LayoutKind.Auto)]
+    internal struct FVoid : ICriticalNotifyCompletion
+    {
+        [DebuggerHidden]
+        public void Coroutine()
+        {
+            
+        }
+        
+        [DebuggerHidden]
+        public void OnCompleted(Action continuation)
+        {
+            
+        }
+        
+        [DebuggerHidden]
+        public void UnsafeOnCompleted(Action continuation)
+        {
+            
+        }
+    }
+}
--- a/Assets/GameScripts/DotNet/Core/Task/FVoid.cs.meta
+++ b/Assets/GameScripts/DotNet/Core/Task/FVoid.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c43e35df403ff9a468b6805bd64181f7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/GameScripts/DotNet/Core/Task/Partial.meta
+++ b/Assets/GameScripts/DotNet/Core/Task/Partial.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 2cc519fac78a9574594b7ee2811a1c68
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/GameScripts/DotNet/Core/Task/Partial/FTask.Factory.cs
+++ b/Assets/GameScripts/DotNet/Core/Task/Partial/FTask.Factory.cs
@@ -0,0 +1,26 @@
+using System;
+
+namespace TEngine
+{
+    public partial class FTask
+    {
+        public static FTaskCompleted CompletedTask => new();
+
+        public static FTask Run(Func<FTask> factory)
+        {
+            return factory();
+        }
+
+        public static FTask<T> Run<T>(Func<FTask<T>> factory)
+        {
+            return factory();
+        }
+
+        public static FTask<T> FromResult<T>(T value)
+        {
+            var sAwaiter = FTask<T>.Create();
+            sAwaiter.SetResult(value);
+            return sAwaiter;
+        }
+    }
+}
--- a/Assets/GameScripts/DotNet/Core/Task/Partial/FTask.Factory.cs.meta
+++ b/Assets/GameScripts/DotNet/Core/Task/Partial/FTask.Factory.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ac04f3959fd37ad48b2bb6bb7ddb4d46
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/GameScripts/DotNet/Core/Task/Partial/FTask.Pool.cs
+++ b/Assets/GameScripts/DotNet/Core/Task/Partial/FTask.Pool.cs
@@ -0,0 +1,29 @@
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+
+namespace TEngine
+{
+    public partial class FTask
+    {
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static FTask Create(bool isFromPool = true)
+        {
+            var task = isFromPool ? Pool<FTask>.Rent() : new FTask();
+            task._isFromPool = isFromPool;
+            return task;
+        }
+    }
+
+    public partial class FTask<T>
+    {
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static FTask<T> Create(bool isFromPool = true)
+        {
+            var task = isFromPool ? Pool<FTask<T>>.Rent() : new FTask<T>();
+            task._isFromPool = isFromPool;
+            return task;
+        }
+    }
+}
--- a/Assets/GameScripts/DotNet/Core/Task/Partial/FTask.Pool.cs.meta
+++ b/Assets/GameScripts/DotNet/Core/Task/Partial/FTask.Pool.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: dfe1e7044d17abb41a98dd6e2ad51896
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/GameScripts/DotNet/Core/Task/Partial/FTask.WhenAll.cs
+++ b/Assets/GameScripts/DotNet/Core/Task/Partial/FTask.WhenAll.cs
@@ -0,0 +1,157 @@
+using System.Collections.Generic;
+
+namespace TEngine
+{
+    public partial class FTask
+    {
+        public static async FTask WhenAll(List<FTask> tasks)
+        {
+            if (tasks.Count <= 0)
+            {
+                return;
+            }
+            
+            var count = tasks.Count;
+            var sTaskCompletionSource = Create();
+     
+            foreach (var task in tasks)
+            {
+                RunSTask(sTaskCompletionSource, task).Coroutine();
+            }
+
+            await sTaskCompletionSource;
+
+            async FVoid RunSTask(FTask tcs, FTask task)
+            {
+                await task;
+                count--;
+                
+                if (count <= 0)
+                {
+                    tcs.SetResult();
+                }
+            }
+        }
+        
+        public static async FTask Any(params FTask[] tasks)
+        {
+            if (tasks == null || tasks.Length <= 0)
+            {
+                return;
+            }
+
+            var tcs = FTask.Create();
+
+            int count = 1;
+            
+            foreach (FTask task in tasks)
+            {
+                RunSTask(task).Coroutine();
+            }
+            
+            await tcs;
+
+            async FVoid RunSTask(FTask task)
+            {
+                await task;
+
+                count--;
+
+                if (count == 0)
+                {
+                    tcs.SetResult();
+                }
+            }
+        }
+    }
+
+    public partial class FTask<T>
+    {
+        public static async FTask WhenAll(List<FTask<T>> tasks)
+        {
+            if (tasks.Count <= 0)
+            {
+                return;
+            }
+            
+            var count = tasks.Count;
+            var sTaskCompletionSource = FTask.Create();
+
+            foreach (var task in tasks)
+            {
+                RunSTask(sTaskCompletionSource, task).Coroutine();
+            }
+
+            await sTaskCompletionSource;
+
+            async FVoid RunSTask(FTask tcs, FTask<T> task)
+            {
+                await task;
+                count--;
+                if (count == 0)
+                {
+                    tcs.SetResult();
+                }
+            }
+        }
+        
+        public static async FTask WhenAll(params FTask<T>[] tasks)
+        {
+            if (tasks == null || tasks.Length <= 0)
+            {
+                return;
+            }
+            
+            var count = tasks.Length;
+            var tcs = FTask.Create();
+
+            foreach (var task in tasks)
+            {
+                RunSTask(task).Coroutine();
+            }
+
+            await tcs;
+
+            async FVoid RunSTask(FTask<T> task)
+            {
+                await task;
+                count--;
+                if (count == 0)
+                {
+                    tcs.SetResult();
+                }
+            }
+        }
+
+        public static async FTask WaitAny(params FTask<T>[] tasks)
+        {
+            if (tasks == null || tasks.Length <= 0)
+            {
+                return;
+            }
+
+            var tcs = FTask.Create();
+
+            int count = 1;
+            
+            foreach (FTask<T> task in tasks)
+            {
+                RunSTask(task).Coroutine();
+            }
+            
+            await tcs;
+
+            async FVoid RunSTask(FTask<T> task)
+            {
+                await task;
+
+                count--;
+
+                if (count == 0)
+                {
+                    tcs.SetResult();
+                }
+            }
+        }
+    }
+}
--- a/Assets/GameScripts/DotNet/Core/Task/Partial/FTask.WhenAll.cs.meta
+++ b/Assets/GameScripts/DotNet/Core/Task/Partial/FTask.WhenAll.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ef20b979a90164a45ad1e3ee2e5b1b09
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: