Added failure check for async tasks

Author: altunsercan

UnityProject/Assets/Plugins/Zenject/OptionalExtras/Async/Runtime/AsyncInject.cs

@@ -29,10 +29,11 @@ public class AsyncInject<T> : AsyncInject
         public event Action Cancelled;
 
         public bool HasResult { get; protected set; }
+        public bool IsSuccessful { get; protected set; }
         public bool IsCancelled  { get; protected set; }
         public bool IsFaulted  { get; protected set; }
 
-        public bool IsCompleted => HasResult || IsCancelled || IsFaulted;
+        public bool IsCompleted => IsSuccessful || IsCancelled || IsFaulted;
 
         T _result;
         Task<T> task;
@@ -56,30 +57,60 @@ public void Cancel()
 
         protected async void StartAsync(Func<CancellationToken, Task<T>> asyncMethod, CancellationToken token)
         {
-            task = asyncMethod(token);
-            await task;
-            
+            try
+            {
+                task = asyncMethod(token);
+                await task;
+            }
+            catch (AggregateException e)
+            {
+                HandleFaulted(e);
+                return;
+            }
+            catch (Exception e)
+            {
+                HandleFaulted(new AggregateException(e));
+                return;
+            }
+
             if (token.IsCancellationRequested)
             {
+                HandleCancelled();
                 return;
             }
 
             if (task.IsCompleted)
             {
-                _result = task.Result;
-                HasResult = true;
-                Completed?.Invoke(task.Result);
+                HandleCompleted(task.Result);
             }else if (task.IsCanceled)
             {
-                IsCancelled = true;
-                Cancelled?.Invoke();
+                HandleCancelled();
             }else if (task.IsFaulted)
             {
-                IsFaulted = true;
-                Faulted?.Invoke(task.Exception);
+                HandleFaulted(task.Exception);
             }
         }
 
+        private void HandleCompleted(T result)
+        {
+            _result = result;
+            HasResult = !result.Equals(default(T));
+            IsSuccessful = true;
+            Completed?.Invoke(result);
+        }
+
+        private void HandleCancelled()
+        {
+            IsCancelled = true;
+            Cancelled?.Invoke();
+        }
+
+        private void HandleFaulted(AggregateException exception)
+        {
+            IsFaulted = true;
+            Faulted?.Invoke(exception);
+        }
+
         public bool TryGetResult(out T result)
         {
             if (HasResult)

UnityProject/Assets/Plugins/Zenject/OptionalExtras/Async/Tests/Addressable/TestAddressable.cs

@@ -3,12 +3,10 @@
 using Zenject;
 using System.Collections;
 using System.Collections.Generic;
-using ModestTree;
 using NUnit.Framework;
 using UnityEngine;
 using UnityEngine.TestTools;
 using UnityEngine.AddressableAssets;
-using UnityEngine.ResourceManagement;
 using UnityEngine.ResourceManagement.AsyncOperations;
 using UnityEngine.ResourceManagement.ResourceLocations;
 using Assert = NUnit.Framework.Assert;
@@ -100,6 +98,46 @@ public IEnumerator TestAssetReferenceTMethod()
         Addressables.Release(asyncPrefab.AssetReferenceHandle);
         Assert.Pass();
     }
+    
+    [UnityTest]
+    [Timeout(10500)]
+    public IEnumerator TestFailedLoad()
+    {
+        PreInstall();
+        
+        Container.BindAsync<GameObject>().FromMethod(async () =>
+        {
+            FailedOperation failingOperation = new FailedOperation();
+            var customHandle = Addressables.ResourceManager.StartOperation(failingOperation, default(AsyncOperationHandle));   
+            await customHandle.Task;
+
+            if (customHandle.Status == AsyncOperationStatus.Failed)
+            {
+                throw new Exception("Async operation failed", customHandle.OperationException);
+            }
+            
+            return customHandle.Result;
+        }).AsCached();
+        PostInstall();
+
+        yield return new WaitForEndOfFrame();
+        
+        LogAssert.ignoreFailingMessages = true;
+        AsyncInject<GameObject> asyncGameObj = Container.Resolve<AsyncInject<GameObject>>();
+        LogAssert.ignoreFailingMessages = false;
+
+        Assert.IsFalse(asyncGameObj.HasResult);
+        Assert.IsTrue(asyncGameObj.IsCompleted);
+        Assert.IsTrue(asyncGameObj.IsFaulted);
+    }
+
+    private class FailedOperation : AsyncOperationBase<GameObject>
+    {
+        protected override void Execute()
+        {
+            Complete(null, false, "Intentionally failed message");
+        }
+    }
 
     private IEnumerator ValidateTestDependency()
     {