Merge pull request #9 from tanitaka-tech/release/v2.0.0

Release/v2.0.0

Author: tanitaka-tech

README.md

@@ -84,12 +84,62 @@ await ConcurrentProcess.Create(
         .LoopProcessAsync(cancellationToken: ct);
 ```
 
-# Logging
+## LiteRequestBroker
+
+LiteRequestBroker is a class that can be used to send requests without using the RequestHandler class.
+
+It is good to use in the following cases:
+- The request does not have any parameters
+- If the request is not being waited simultaneously
+
+### ① Bind LiteRequestBroker
+```cs
+// ----- In some installer
+
+var liteRequestBroker = new LiteRequestBroker();
+Container.BindInstance<ILiteRequestPusher>(liteRequestBroker);
+Container.BindInstance<ILiteRequestConsumer>(liteRequestBroker);
+```
+
+### ② Push Request (R3 Example)
+```cs
+// ----- In some object
+[SerializeField] private Button _closeButton;
+[Inject] private ILiteRequestPusher _liteRequestPusher;
+private void Start()
+{
+        _closeButton.OnClickAsObservable()
+                // I reccommend defining a const string for each request
+                .Subscribe(_ => _liteRequestPusher.PushRequest("CloseRequest"))
+                .AddTo(this);
+}
+```
+
+### ③ Wait Request
+```cs
+await ConcurrentProcess.Create(  
+        Process.Create(  
+            waitTask: async ct => await LiteRequestConcumer.WaitRequestAndConsumeAsync("CloseRequest", ct),  
+            onPassedTask: async ct =>  
+            {  
+                await CloseAsync(ct);
+                return ProcessContinueType.Break;
+            }),
+          
+            // ...
+        )    
+        .LoopProcessAsync(cancellationToken: ct);
+```
+
+
+## Logging
 
 You can enable logging by defining the following:
 
 `UNITY_PROCESS_MANAGER_LOGGER`
 
+### ConcurrentProcess Logging
+
 ```csharp
 await ConcurrentProcess.CreateWithLog(
        Logger, // Some Microsoft.Extensions.Logging implements class.(I recommend using ZLogger)
@@ -98,6 +148,11 @@ await ConcurrentProcess.CreateWithLog(
        .LoopProcessAsync(cancellationToken: cancellationToken);
 ```
 
+### LiteRequestBroker Logging
+
+```csharp
+var liteRequestBroker = new LiteRequestBroker(Logger);
+```
 
 
 ## Installation ☘️

README_JA.md

@@ -17,8 +17,6 @@
 2. `RequestConsumer`を使用して、RequestのPushをawait
 3. `ConcurrentProcess`を使用して、複数の`RequestConsumer`の並列待機し、各Requestが来た時の処理を個別に記述
 
-## コード例
-
 ### ① Bind RequestHandler (Zenject Example)
 ```cs
 // ----- In some installer
@@ -92,12 +90,61 @@ await ConcurrentProcess.Create(
         .LoopProcessAsync(cancellationToken: ct);
 ```
 
-# Logging
+## LiteRequestBroker
+
+LiteRequestBrokerは、RequestHandlerクラスを使用せずにリクエストを送信するために使用できるクラスです。
+
+下記のような場合に使用することをおすすめします。
+- リクエストがパラメータを持たない時
+- 同じリクエストが同時に待機されない時
+
+### ① Bind LiteRequestBroker
+```cs
+// ----- In some installer
+
+var liteRequestBroker = new LiteRequestBroker();
+Container.BindInstance<ILiteRequestPusher>(liteRequestBroker);
+Container.BindInstance<ILiteRequestConsumer>(liteRequestBroker);
+```
+
+### ② Push Request (R3 Example)
+```cs
+// ----- In some object
+[SerializeField] private Button _closeButton;
+[Inject] private ILiteRequestPusher _liteRequestPusher;
+private void Start()
+{
+        _closeButton.OnClickAsObservable()
+                // I reccommend defining a const string for each request
+                .Subscribe(_ => _liteRequestPusher.PushRequest("CloseRequest"))
+                .AddTo(this);
+}
+```
+
+### ③ Wait Request
+```cs
+await ConcurrentProcess.Create(  
+        Process.Create(  
+            waitTask: async ct => await LiteRequestConcumer.WaitRequestAndConsumeAsync("CloseRequest", ct),  
+            onPassedTask: async ct =>  
+            {  
+                await CloseAsync(ct);
+                return ProcessContinueType.Break;
+            }),
+          
+            // ...
+        )    
+        .LoopProcessAsync(cancellationToken: ct);
+```
+
+## Logging
 
 下記のdefine symbolを定義することでログ関連の実装を有効にできます。
 
 `UNITY_PROCESS_MANAGER_LOGGER`
 
+### ConcurrentProcessのログ対応
+
 ```csharp
 await ConcurrentProcess.CreateWithLog(
        Logger, // Microsoft.Extensions.Loggingを継承したクラス(ログ出しにはZLoggerがおすすめです)
@@ -106,6 +153,11 @@ await ConcurrentProcess.CreateWithLog(
        .LoopProcessAsync(cancellationToken: cancellationToken);
 ```
 
+### LiteRequestBrokerのログ対応
+```csharp
+var liteRequestBroker = new LiteRequestBroker(Logger);
+```
+
 ## Installation ☘️
 
 ### Install via git URL

Runtime/ConcurrentProcess.cs

@@ -11,11 +11,11 @@ namespace TanitakaTech.UnityProcessManager
 {
     public readonly struct ConcurrentProcess
     {
-        private Memory<Process> Processes { get; }
+        private readonly Memory<Process> _processes;
 
         private ConcurrentProcess(params Process[] processTasks)
         {
-            Processes = new Memory<Process>(processTasks);
+            _processes = new Memory<Process>(processTasks);
         }
 
         public static ConcurrentProcess Create(params Process[] processTasks)
@@ -57,16 +57,16 @@ public static ConcurrentProcess CreateWithLog(ILogger logger, params IProcessPro
         public static ConcurrentProcess Create(params ConcurrentProcess[] concurrentProcesses)
         {
             return new ConcurrentProcess(
-                concurrentProcesses.SelectMany(concurrentProcess => concurrentProcess.Processes.ToArray()).ToArray()
+                concurrentProcesses.SelectMany(concurrentProcess => concurrentProcess._processes.ToArray()).ToArray()
             );
         }
 
         public ConcurrentProcess With(params ConcurrentProcess[] concurrentProcesses)
         {
             return new ConcurrentProcess(
                 concurrentProcesses
-                    .SelectMany(concurrentProcess => concurrentProcess.Processes.ToArray())
-                    .Concat(Processes.ToArray())
+                    .SelectMany(concurrentProcess => concurrentProcess._processes.ToArray())
+                    .Concat(_processes.ToArray())
                     .ToArray()
             );
         }
@@ -84,15 +84,16 @@ private async UniTask<ProcessContinueType> InternalProcessAsync(CancellationToke
         {
             CancellationTokenSource cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
 
-            UniTask[] tasks = new UniTask[Processes.Length];
-            for (int i = 0; i < Processes.Length; i++)
+            var length = _processes.Length;
+            UniTask[] tasks = new UniTask[length];
+            for (int i = 0; i < length; i++)
             {
-                tasks[i] = Processes.Span[i].WaitTask(cancellationTokenSource.Token);
+                tasks[i] = _processes.Span[i].WaitTask(cancellationTokenSource.Token);
             }
 
             var passedTaskIndex = await UniTask.WhenAny(tasks);
             cancellationTokenSource.Cancel();
-            return await Processes.Span[passedTaskIndex].OnPassedTask(cancellationToken);
+            return await _processes.Span[passedTaskIndex].OnPassedTask(cancellationToken);
         }
     }
 }

Runtime/Request/ILiteRequestConsumer.cs

@@ -0,0 +1,10 @@
+using System.Threading;
+using Cysharp.Threading.Tasks;
+
+namespace TanitakaTech.UnityProcessManager
+{
+    public interface ILiteRequestConsumer
+    {
+        UniTask WaitRequestAndConsumeAsync(string waitRequest, CancellationToken cancellationToken);
+    }
+}

Runtime/Request/ILiteRequestConsumer.cs.meta

@@ -0,0 +1,7 @@
+namespace TanitakaTech.UnityProcessManager
+{
+    public interface ILiteRequestPusher
+    {
+        void PushRequest(string request);
+    }
+}

Runtime/Request/ILiteRequestPusher.cs

@@ -5,6 +5,6 @@ namespace TanitakaTech.UnityProcessManager
 {
     public interface IRequestConsumer<TRequest>
     {
-        public UniTask<TRequest> WaitRequestAndConsumeAsync(CancellationToken cancellationToken);
+        UniTask<TRequest> WaitRequestAndConsumeAsync(CancellationToken cancellationToken);
     }
 }

Runtime/Request/ILiteRequestPusher.cs.meta

@@ -2,6 +2,6 @@
 {
     public interface IRequestPusher<TRequest>
     {
-        public void PushRequest(TRequest requestValue);
+        void PushRequest(TRequest requestValue);
     }
 }

Runtime/Request/IRequestConsumer.cs

@@ -0,0 +1,65 @@
+using System.Collections.Generic;
+using System.Threading;
+using Cysharp.Threading.Tasks;
+
+#if UNITY_PROCESS_MANAGER_LOGGER
+using Microsoft.Extensions.Logging;
+#endif
+
+namespace TanitakaTech.UnityProcessManager
+{
+    public class LiteRequestBroker : 
+        ILiteRequestPusher,
+        ILiteRequestConsumer
+    {
+#if UNITY_PROCESS_MANAGER_LOGGER
+        private readonly ILogger _logger;
+#endif
+        private readonly HashSet<string> _waitRequests;
+
+        public LiteRequestBroker(
+#if UNITY_PROCESS_MANAGER_LOGGER
+            ILogger logger,
+#endif
+            int initialCapacity = 32
+            )
+        {
+#if UNITY_PROCESS_MANAGER_LOGGER
+            _logger = logger;
+#endif
+            _waitRequests = new HashSet<string>(initialCapacity);
+        }
+
+        public LiteRequestBroker(int initialCapacity)
+        {
+            _waitRequests = new HashSet<string>(initialCapacity);
+        }
+        
+        void ILiteRequestPusher.PushRequest(string request)
+        {
+            if (_waitRequests.Contains(request))
+            {
+                _waitRequests.Remove(request);
+            }
+#if UNITY_PROCESS_MANAGER_LOGGER
+            else
+            {
+                _logger.LogInformation("Any consumer is not waiting for a {0}", request);
+            }
+#endif
+        }
+
+        async UniTask ILiteRequestConsumer.WaitRequestAndConsumeAsync(string waitRequest, CancellationToken cancellationToken)
+        {
+#if UNITY_PROCESS_MANAGER_LOGGER
+            _logger.LogInformation("Start waiting for a {0}", waitRequest);
+#endif
+            _waitRequests.Add(waitRequest);
+            cancellationToken.Register(() => _waitRequests.Remove(waitRequest));
+            await UniTask.WaitUntil(() => !_waitRequests.Contains(waitRequest), cancellationToken: cancellationToken);
+#if UNITY_PROCESS_MANAGER_LOGGER
+            _logger.LogInformation("{0} was consumed", waitRequest);
+#endif
+        }
+    }
+}