refactor(util): use 'using' statements instead of try-finally

Convert try-finally patterns to 'using' declarations for cleaner
resource management as suggested by CodeQL static analysis.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Signed-off-by: JasonXuDeveloper - 傑 <jason@xgamedev.net>

Author: JasonXuDeveloper

UnityProject/Packages/com.jasonxudeveloper.jengine.util/Tests/Editor/JActionTests.cs

@@ -626,65 +626,47 @@ public void DelayFrame_NegativeValue_SkipsDelay()
         [Test]
         public void TaskCapacity_ThrowsWhenExceeded()
         {
-            var action = JAction.Create();
-            try
-            {
-                // Add 256 tasks (the max capacity)
-                for (int i = 0; i < 256; i++)
-                {
-                    action.Do(() => { });
-                }
+            using var action = JAction.Create();
 
-                // The 257th task should throw
-                Assert.Throws<InvalidOperationException>(() => action.Do(() => { }));
-            }
-            finally
+            // Add 256 tasks (the max capacity)
+            for (int i = 0; i < 256; i++)
             {
-                action.Dispose();
+                action.Do(() => { });
             }
+
+            // The 257th task should throw
+            Assert.Throws<InvalidOperationException>(() => action.Do(() => { }));
         }
 
         [Test]
         public void Reset_ClearsTasks()
         {
             int counter = 0;
 
-            var action = JAction.Create()
+            using var action = JAction.Create()
                 .Do(() => counter++)
                 .Do(() => counter++);
-            try
-            {
-                // Reset should clear the tasks
-                action.Reset();
 
-                // Execute after reset - should do nothing (no tasks)
-                action.Execute();
+            // Reset should clear the tasks
+            action.Reset();
 
-                Assert.AreEqual(0, counter);
-            }
-            finally
-            {
-                action.Dispose();
-            }
+            // Execute after reset - should do nothing (no tasks)
+            action.Execute();
+
+            Assert.AreEqual(0, counter);
         }
 
         [Test]
         public void Reset_ClearsParallelMode()
         {
-            var action = JAction.Create()
+            using var action = JAction.Create()
                 .Parallel();
-            try
-            {
-                Assert.IsTrue(action.IsParallel);
 
-                action.Reset();
+            Assert.IsTrue(action.IsParallel);
 
-                Assert.IsFalse(action.IsParallel);
-            }
-            finally
-            {
-                action.Dispose();
-            }
+            action.Reset();
+
+            Assert.IsFalse(action.IsParallel);
         }
 
         #endregion

UnityProject/Packages/com.jasonxudeveloper.jengine.util/Tests/Runtime/JActionRuntimeTests.cs

@@ -434,27 +434,20 @@ public IEnumerator Do_AsyncFunc_WaitsForCompletion()
             return RunAsync(async () =>
             {
                 // Create an inner action that we'll wait for
-                var innerAction = JAction.Create()
+                using var innerAction = JAction.Create()
                     .Do(static o => o.Add(1), order)
                     .DelayFrame(2)
                     .Do(static o => o.Add(2), order);
-                try
-                {
-                    using var action = await JAction.Create()
-                        .Do(static o => o.Add(0), order)
-                        .Do(static act => { _ = act.ExecuteAsync(); }, innerAction) // Fire and forget
-                        .Do(static o => o.Add(3), order)
-                        .ExecuteAsync();
-
-                    // The inner action executes asynchronously, so order depends on timing
-                    Assert.Contains(0, order);
-                    Assert.Contains(3, order);
-                }
-                finally
-                {
-                    // Clean up inner action
-                    innerAction.Dispose();
-                }
+
+                using var action = await JAction.Create()
+                    .Do(static o => o.Add(0), order)
+                    .Do(static act => { _ = act.ExecuteAsync(); }, innerAction) // Fire and forget
+                    .Do(static o => o.Add(3), order)
+                    .ExecuteAsync();
+
+                // The inner action executes asynchronously, so order depends on timing
+                Assert.Contains(0, order);
+                Assert.Contains(3, order);
             });
         }
 
@@ -497,7 +490,7 @@ public IEnumerator Parallel_AllowsConcurrentExecution()
             return RunAsync(async () =>
             {
                 // Create a parallel action
-                var action = JAction.Create()
+                using var action = JAction.Create()
                     .Parallel()
                     .Do(() =>
                     {
@@ -506,23 +499,17 @@ public IEnumerator Parallel_AllowsConcurrentExecution()
                     })
                     .DelayFrame(2)
                     .Do(() => concurrentCount--);
-                try
-                {
-                    // Start multiple executions concurrently
-                    var task1 = action.ExecuteAsync();
-                    var task2 = action.ExecuteAsync();
 
-                    await task1;
-                    await task2;
+                // Start multiple executions concurrently
+                var task1 = action.ExecuteAsync();
+                var task2 = action.ExecuteAsync();
 
-                    // With parallel mode, both should have run
-                    // Note: maxConcurrent may be 1 or 2 depending on timing
-                    Assert.GreaterOrEqual(maxConcurrent, 1);
-                }
-                finally
-                {
-                    action.Dispose();
-                }
+                await task1;
+                await task2;
+
+                // With parallel mode, both should have run
+                // Note: maxConcurrent may be 1 or 2 depending on timing
+                Assert.GreaterOrEqual(maxConcurrent, 1);
             });
         }
 
@@ -534,36 +521,30 @@ public IEnumerator NonParallel_BlocksConcurrentExecution()
             return RunAsync(async () =>
             {
                 // Create a non-parallel action (default)
-                var action = JAction.Create()
+                using var action = JAction.Create()
                     .Do(() => executionCount++)
                     .DelayFrame(2);
-                try
-                {
-                    // Start first execution
-                    var task1 = action.ExecuteAsync();
 
-                    // Verify action is executing
-                    Assert.IsTrue(action.Executing);
+                // Start first execution
+                var task1 = action.ExecuteAsync();
 
-                    // Try to start second execution while first is running
-                    // This should log a warning and return immediately
-                    LogAssert.Expect(LogType.Warning,
-                        "[JAction] Already executing. Enable Parallel() for concurrent execution.");
-                    var task2 = action.ExecuteAsync();
+                // Verify action is executing
+                Assert.IsTrue(action.Executing);
 
-                    // task2 should complete immediately (returns early)
-                    await task2;
+                // Try to start second execution while first is running
+                // This should log a warning and return immediately
+                LogAssert.Expect(LogType.Warning,
+                    "[JAction] Already executing. Enable Parallel() for concurrent execution.");
+                var task2 = action.ExecuteAsync();
 
-                    // Wait for first execution to complete
-                    await task1;
+                // task2 should complete immediately (returns early)
+                await task2;
 
-                    // Only the first execution should have incremented
-                    Assert.AreEqual(1, executionCount);
-                }
-                finally
-                {
-                    action.Dispose();
-                }
+                // Wait for first execution to complete
+                await task1;
+
+                // Only the first execution should have incremented
+                Assert.AreEqual(1, executionCount);
             });
         }
 
@@ -711,32 +692,26 @@ public IEnumerator Cancel_DuringAsyncExecution_StopsExecution()
 
             return RunAsync(async () =>
             {
-                var action = JAction.Create()
+                using var action = JAction.Create()
                     .Do(() => step1 = true)
                     .Delay(1f)
                     .Do(() => step2 = true)
                     .OnCancel(() => cancelled = true);
-                try
-                {
-                    // Start execution (don't await yet)
-                    var handle = action.ExecuteAsync();
 
-                    // Wait a bit then cancel via handle (per-execution cancellation)
-                    await UniTask.Delay(50);
-                    handle.Cancel();
+                // Start execution (don't await yet)
+                var handle = action.ExecuteAsync();
 
-                    // Now await the handle to get the result
-                    var result = await handle;
+                // Wait a bit then cancel via handle (per-execution cancellation)
+                await UniTask.Delay(50);
+                handle.Cancel();
 
-                    Assert.IsTrue(step1);
-                    Assert.IsFalse(step2);
-                    Assert.IsTrue(cancelled);
-                    Assert.IsTrue(result.Cancelled);
-                }
-                finally
-                {
-                    action.Dispose();
-                }
+                // Now await the handle to get the result
+                var result = await handle;
+
+                Assert.IsTrue(step1);
+                Assert.IsFalse(step2);
+                Assert.IsTrue(cancelled);
+                Assert.IsTrue(result.Cancelled);
             });
         }
 
@@ -747,33 +722,27 @@ public IEnumerator Cancel_ParallelExecution_CancelsOnlySpecificHandle()
 
             return RunAsync(async () =>
             {
-                var action = JAction.Create()
+                using var action = JAction.Create()
                     .Parallel()
                     .Delay(1f)
                     .OnCancel(() => cancelCount++);
-                try
-                {
-                    // Start two parallel executions
-                    var handle1 = action.ExecuteAsync();
-                    var handle2 = action.ExecuteAsync();
-
-                    // Wait a bit then cancel only handle1
-                    await UniTask.Delay(50);
-                    handle1.Cancel();
-
-                    // Await both
-                    var result1 = await handle1;
-                    var result2 = await handle2;
-
-                    // Only handle1 should be cancelled
-                    Assert.IsTrue(result1.Cancelled);
-                    Assert.IsFalse(result2.Cancelled);
-                    Assert.AreEqual(1, cancelCount);
-                }
-                finally
-                {
-                    action.Dispose();
-                }
+
+                // Start two parallel executions
+                var handle1 = action.ExecuteAsync();
+                var handle2 = action.ExecuteAsync();
+
+                // Wait a bit then cancel only handle1
+                await UniTask.Delay(50);
+                handle1.Cancel();
+
+                // Await both
+                var result1 = await handle1;
+                var result2 = await handle2;
+
+                // Only handle1 should be cancelled
+                Assert.IsTrue(result1.Cancelled);
+                Assert.IsFalse(result2.Cancelled);
+                Assert.AreEqual(1, cancelCount);
             });
         }