Merge pull request #100 from hadashiA/ku/unitask-integration

UniTask integration

.github/workflows/test.yaml

@@ -56,7 +56,8 @@ jobs:
     - name: Run Tests
       shell: bash
       run: xvfb-run --error-file=/dev/stdout --auto-servernum --server-args='-screen 0 1024x768x24' /opt/Unity/Editor/Unity -batchmode -logFile /dev/stdout -projectPath ./VContainer -runTests -testResults $GITHUB_WORKSPACE/VContainer/tmp/TestResults.xml -testPlatform playmode -buildTarget StandaloneLinux64 -scriptbackend=${{ matrix.scriptBackend }} -nographics -silent-crashes
-    - uses: actions/upload-artifact@v1
+    - uses: actions/upload-artifact@v2
+      if: always()
       with:
-        name: Test results
+        name: TestResults.xml
         path: ./VContainer/tmp/TestResults.xml

README.md

@@ -22,6 +22,7 @@ The extra fast DI (Dependency Injection) library running on Unity Game Engine.
 - Flexible scoping
   - Application can freely create nested Lifetime Scope with any async way for you like.
 - Pre IL Code generation optimization mode
+- UniTask Integration
 - ECS Integration *beta*
 
 ## Performance
@@ -30,8 +31,6 @@ The extra fast DI (Dependency Injection) library running on Unity Game Engine.
 
 ### GC Alloc Result Example
 
-
-
 ![](./website/static/img/gc_alloc_profiler_result.png)
 
 ![](./website/static/img/screenshot_profiler_vcontainer.png)
@@ -232,6 +231,24 @@ using (LifetimeScope.Enqueue(builder =>
 }
 ```
 
+## UniTask
+
+```csharp
+public class FooController : IAsyncStartable
+{
+    public async UniTask StartAsync(CancellationToken cancellation)
+    {
+        await LoadSomethingAsync(cancellation);
+        await ...
+        ...
+    }
+}
+```
+
+```csharp
+builder.RegisterEntryPoint<FooController>(Lifetime.Scoped);
+```
+
 ## Documentation
 
 Visit [vcontainer.hadashikick.jp](https://vcontainer.hadashikick.jp) to view the full documentation.

VContainer/Assets/VContainer/Runtime/Interfaces/IAsyncStartable.cs

@@ -0,0 +1,12 @@
+#if VCONTAINER_UNITASK_INTEGRATION
+using System.Threading;
+using Cysharp.Threading.Tasks;
+
+namespace VContainer.Unity
+{
+    public interface IAsyncStartable
+    {
+        UniTask StartAsync(CancellationToken cancellation);
+    }
+}
+#endif

VContainer/Assets/VContainer/Runtime/Interfaces/IFixedTickable.cs

@@ -0,0 +1,7 @@
+namespace VContainer.Unity
+{
+    public interface IFixedTickable
+    {
+        void FixedTick();
+    }
+}

VContainer/Assets/VContainer/Runtime/Interfaces/IInitializable.cs

@@ -0,0 +1,7 @@
+namespace VContainer.Unity
+{
+    public interface IInitializable
+    {
+        void Initialize();
+    }
+}

VContainer/Assets/VContainer/Runtime/Interfaces/ILateTickable.cs

@@ -0,0 +1,7 @@
+namespace VContainer.Unity
+{
+    public interface ILateTickable
+    {
+        void LateTick();
+    }
+}

VContainer/Assets/VContainer/Runtime/Interfaces/IPostFixedTickable.cs

@@ -0,0 +1,7 @@
+namespace VContainer.Unity
+{
+    public interface IPostFixedTickable
+    {
+        void PostFixedTick();
+    }
+}

VContainer/Assets/VContainer/Runtime/Interfaces/IPostInitializable.cs

@@ -0,0 +1,7 @@
+namespace VContainer.Unity
+{
+    public interface IPostInitializable
+    {
+        void PostInitialize();
+    }
+}

VContainer/Assets/VContainer/Runtime/Interfaces/IPostLateTickable.cs

@@ -0,0 +1,7 @@
+namespace VContainer.Unity
+{
+    public interface IPostLateTickable
+    {
+        void PostLateTick();
+    }
+}

VContainer/Assets/VContainer/Runtime/Interfaces/IPostStartable.cs

@@ -0,0 +1,7 @@
+namespace VContainer.Unity
+{
+    public interface IPostStartable
+    {
+        void PostStart();
+    }
+}

VContainer/Assets/VContainer/Runtime/Interfaces/IPostTickable.cs

@@ -0,0 +1,7 @@
+namespace VContainer.Unity
+{
+    public interface IPostTickable
+    {
+        void PostTick();
+    }
+}

VContainer/Assets/VContainer/Runtime/Interfaces/IStartable.cs

@@ -0,0 +1,7 @@
+namespace VContainer.Unity
+{
+    public interface IStartable
+    {
+        void Start();
+    }
+}

VContainer/Assets/VContainer/Runtime/Interfaces/ITickable.cs

@@ -0,0 +1,7 @@
+namespace VContainer.Unity
+{
+    public interface ITickable
+    {
+        void Tick();
+    }
+}

VContainer/Assets/VContainer/Runtime/Unity/ContainerBuilderUnityExtensions.cs

@@ -1,6 +1,7 @@
 using System;
 using UnityEngine;
 using VContainer.Internal;
+
 #if VCONTAINER_ECS_INTEGRATION
 using Unity.Entities;
 #endif
@@ -20,6 +21,9 @@ public EntryPointsBuilder(IContainerBuilder containerBuilder, Lifetime lifetime)
 
         public RegistrationBuilder Add<T>()
             => containerBuilder.Register<T>(lifetime).AsImplementedInterfaces();
+
+        public void OnException(Action<Exception> exceptionHandler)
+            => containerBuilder.RegisterEntryPointExceptionHandler(exceptionHandler);
     }
 
     public readonly struct ComponentsBuilder
@@ -57,6 +61,13 @@ public static void UseEntryPoints(
             configuration(entryPoints);
         }
 
+        public static void RegisterEntryPointExceptionHandler(
+            this IContainerBuilder builder,
+            Action<Exception> exceptionHandler)
+        {
+            builder.RegisterInstance(new EntryPointExceptionHandler(exceptionHandler));
+        }
+
         public static void UseComponents(this IContainerBuilder builder, Action<ComponentsBuilder> configuration)
         {
             var components = new ComponentsBuilder(builder);

VContainer/Assets/VContainer/Runtime/Unity/EntryPointExceptionHandler.cs

@@ -0,0 +1,19 @@
+using System;
+
+namespace VContainer.Unity
+{
+    sealed class EntryPointExceptionHandler
+    {
+        readonly Action<Exception> handler;
+
+        public EntryPointExceptionHandler(Action<Exception> handler)
+        {
+            this.handler = handler;
+        }
+
+        public void Publish(Exception ex)
+        {
+            handler.Invoke(ex);
+        }
+    }
+}

VContainer/Assets/VContainer/Runtime/Unity/LifetimeScope.cs

@@ -145,6 +145,10 @@ protected virtual void Configure(IContainerBuilder builder) { }
 
         public void Dispose()
         {
+            disposable.Dispose();
+            Container?.Dispose();
+            Container = null;
+
             if (this != null)
                 Destroy(gameObject);
         }
@@ -288,86 +292,105 @@ void ActivateEntryPoints()
         {
             PlayerLoopHelper.Initialize();
 
+            EntryPointExceptionHandler exceptionHandler = null;
+            try
+            {
+                exceptionHandler = Container.Resolve<EntryPointExceptionHandler>();
+            }
+            catch (VContainerException ex) when (ex.InvalidType == typeof(EntryPointExceptionHandler))
+            {
+            }
+
             var initializables = Container.Resolve<IReadOnlyList<IInitializable>>();
             if (initializables.Count > 0)
             {
-                var loopItem = new InitializationLoopItem(initializables);
+                var loopItem = new InitializationLoopItem(initializables, exceptionHandler);
                 disposable.Add(loopItem);
                 PlayerLoopHelper.Dispatch(PlayerLoopTiming.Initialization, loopItem);
             }
 
             var postInitializables = Container.Resolve<IReadOnlyList<IPostInitializable>>();
             if (postInitializables.Count > 0)
             {
-                var loopItem = new PostInitializationLoopItem(postInitializables);
+                var loopItem = new PostInitializationLoopItem(postInitializables, exceptionHandler);
                 disposable.Add(loopItem);
                 PlayerLoopHelper.Dispatch(PlayerLoopTiming.PostInitialization, loopItem);
             }
 
             var startables = Container.Resolve<IReadOnlyList<IStartable>>();
             if (startables.Count > 0)
             {
-                var loopItem = new StartableLoopItem(startables);
+                var loopItem = new StartableLoopItem(startables, exceptionHandler);
                 disposable.Add(loopItem);
                 PlayerLoopHelper.Dispatch(PlayerLoopTiming.Startup, loopItem);
             }
 
-            var postStartable = Container.Resolve<IReadOnlyList<IPostStartable>>();
-            if (postInitializables.Count > 0)
+            var postStartables = Container.Resolve<IReadOnlyList<IPostStartable>>();
+            if (postStartables.Count > 0)
             {
-                var loopItem = new PostStartableLoopItem(postStartable);
+                var loopItem = new PostStartableLoopItem(postStartables, exceptionHandler);
                 disposable.Add(loopItem);
                 PlayerLoopHelper.Dispatch(PlayerLoopTiming.PostStartup, loopItem);
             }
 
             var fixedTickables = Container.Resolve<IReadOnlyList<IFixedTickable>>();
             if (fixedTickables.Count > 0)
             {
-                var loopItem = new FixedTickableLoopItem(fixedTickables);
+                var loopItem = new FixedTickableLoopItem(fixedTickables, exceptionHandler);
                 disposable.Add(loopItem);
                 PlayerLoopHelper.Dispatch(PlayerLoopTiming.FixedUpdate, loopItem);
             }
 
             var postFixedTickables = Container.Resolve<IReadOnlyList<IPostFixedTickable>>();
             if (postFixedTickables.Count > 0)
             {
-                var loopItem = new PostFixedTickableLoopItem(postFixedTickables);
+                var loopItem = new PostFixedTickableLoopItem(postFixedTickables, exceptionHandler);
                 disposable.Add(loopItem);
                 PlayerLoopHelper.Dispatch(PlayerLoopTiming.PostFixedUpdate, loopItem);
             }
 
             var tickables = Container.Resolve<IReadOnlyList<ITickable>>();
             if (tickables.Count > 0)
             {
-                var loopItem = new TickableLoopItem(tickables);
+                var loopItem = new TickableLoopItem(tickables, exceptionHandler);
                 disposable.Add(loopItem);
                 PlayerLoopHelper.Dispatch(PlayerLoopTiming.Update, loopItem);
             }
 
             var postTickables = Container.Resolve<IReadOnlyList<IPostTickable>>();
             if (postTickables.Count > 0)
             {
-                var loopItem = new PostTickableLoopItem(postTickables);
+                var loopItem = new PostTickableLoopItem(postTickables, exceptionHandler);
                 disposable.Add(loopItem);
                 PlayerLoopHelper.Dispatch(PlayerLoopTiming.PostUpdate, loopItem);
             }
 
             var lateTickables = Container.Resolve<IReadOnlyList<ILateTickable>>();
             if (lateTickables.Count > 0)
             {
-                var loopItem = new LateTickableLoopItem(lateTickables);
+                var loopItem = new LateTickableLoopItem(lateTickables, exceptionHandler);
                 disposable.Add(loopItem);
                 PlayerLoopHelper.Dispatch(PlayerLoopTiming.LateUpdate, loopItem);
             }
 
             var postLateTickables = Container.Resolve<IReadOnlyList<IPostLateTickable>>();
             if (postLateTickables.Count > 0)
             {
-                var loopItem = new PostLateTickableLoopItem(postLateTickables);
+                var loopItem = new PostLateTickableLoopItem(postLateTickables, exceptionHandler);
                 disposable.Add(loopItem);
                 PlayerLoopHelper.Dispatch(PlayerLoopTiming.PostLateUpdate, loopItem);
             }
 
+#if VCONTAINER_UNITASK_INTEGRATION
+            var asyncStartables = Container.Resolve<IReadOnlyList<IAsyncStartable>>();
+            if (asyncStartables.Count > 0)
+            {
+                var loopItem = new AsyncStartableLoopItem(asyncStartables, exceptionHandler);
+                disposable.Add(loopItem);
+                PlayerLoopHelper.Dispatch(PlayerLoopTiming.Startup, loopItem);
+            }
+#endif
+
 #if VCONTAINER_ECS_INTEGRATION
             Container.Resolve<IEnumerable<ComponentSystemBase>>();