add: log extensions

README.md

@@ -84,6 +84,21 @@ await ConcurrentProcess.Create(
         .LoopProcessAsync(cancellationToken: ct);
 ```
 
+# Logging
+
+You can enable logging by defining the following:
+`UNITY_PROCESS_MANAGER_LOGGER`
+
+```csharp
+await ConcurrentProcess.CreateWithLog(
+       Logger, // Some Microsoft.Extensions.Logging implements class.(I recommend using ZLogger)
+       MoveToLicensesProcessProvider // Some IProcessProvider implements class.(This is the class you created)
+       )
+       .LoopProcessAsync(cancellationToken: cancellationToken);
+```
+
+
+
 ## Installation ☘️
 ### Install via git URL
 1. Open the Package Manager

Runtime/ConcurrentProcess.cs

@@ -3,6 +3,10 @@
 using System.Threading;
 using Cysharp.Threading.Tasks;
 
+#if UNITY_PROCESS_MANAGER_LOGGER
+using Microsoft.Extensions.Logging;
+#endif
+
 namespace TanitakaTech.UnityProcessManager
 {
     public readonly struct ConcurrentProcess
@@ -19,6 +23,31 @@ public static ConcurrentProcess Create(params Process[] processTasks)
             return new ConcurrentProcess(processTasks);
         }
 
+        public static ConcurrentProcess Create(params IProcessProvider[] processProviders)
+        {
+            return new ConcurrentProcess(processProviders.Select(processProvider => processProvider.Provide()).ToArray());
+        }
+
+#if UNITY_PROCESS_MANAGER_LOGGER
+        public static ConcurrentProcess CreateWithLog(ILogger logger, params IProcessProvider[] processProviders)
+        {
+            return new ConcurrentProcess(
+                processProviders.Select(processProvider => processProvider.Provide()
+                    .Wrap(Process.Create(waitTask: ct =>
+                        {
+                            logger.LogInformation("WaitTask processProvider: {0}", processProvider.GetType().Name);
+                            return UniTask.CompletedTask;
+                        },
+                        onPassedTask: ct =>
+                        {
+                            logger.LogInformation("OnPassedTask processProvider: {0}",
+                                processProvider.GetType().Name);
+                            return UniTask.FromResult(ProcessContinueType.Continue);
+                        })))
+                    .ToArray());
+        }
+#endif
+
         public static ConcurrentProcess Create(params ConcurrentProcess[] concurrentProcesses)
         {
             return new ConcurrentProcess(

Runtime/IProcessProvider.cs

@@ -0,0 +1,8 @@
+namespace TanitakaTech.UnityProcessManager
+{
+    public interface IProcessProvider
+    {
+        Process Provide();
+    }
+}
+

Runtime/Process.cs

@@ -39,4 +39,23 @@ public UniTask ToUniTask(CancellationToken cancellationToken)
             });
         }
     }
+
+    public static class ProcessExtensions
+    {
+        public static Process Wrap(this Process process, Process wrapProcess)
+        {
+            return Process.Create(
+                waitTask: async ct =>
+                {
+                    await wrapProcess.WaitTask(ct);
+                    await process.WaitTask(ct);
+                },
+                onPassedTask: async ct =>
+                {
+                    await wrapProcess.OnPassedTask(ct);
+                    return await process.OnPassedTask(ct);
+                }
+            );
+        }
+    }
 }

Runtime/Request/RequestHandler.cs

@@ -10,15 +10,15 @@ public class RequestHandler<TRequest> :
         private TRequest _requestValue;
         private bool _isWaitingRequest = false;
 
-        void IRequestPusher<TRequest>.PushRequest(TRequest requestValue)
+        public void PushRequest(TRequest requestValue)
         {
             if (!_isWaitingRequest) return;
 
             _isWaitingRequest = false;
             _requestValue = requestValue;
         }
 
-        async UniTask<TRequest> IRequestConsumer<TRequest>.WaitRequestAndConsumeAsync(CancellationToken cancellationToken)
+        public async UniTask<TRequest> WaitRequestAndConsumeAsync(CancellationToken cancellationToken)
         {
             _isWaitingRequest = true;
             cancellationToken.Register(() => _isWaitingRequest = false);

Runtime/Request/RequestHandlerWithLog.cs

@@ -0,0 +1,36 @@
+#if UNITY_PROCESS_MANAGER_LOGGER
+using System.Threading;
+using Cysharp.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+
+namespace TanitakaTech.UnityProcessManager
+{
+    public class RequestHandlerWithLog<TRequest> :
+        IRequestPusher<TRequest>,
+        IRequestConsumer<TRequest> where TRequest : struct
+    {
+        private ILogger Logger { get; }
+        private RequestHandler<TRequest> RequestHandler { get; }
+
+        public RequestHandlerWithLog(ILogger logger)
+        {
+            Logger = logger;
+            RequestHandler = new RequestHandler<TRequest>();
+        }
+
+        void IRequestPusher<TRequest>.PushRequest(TRequest requestValue)
+        {
+            Logger.LogInformation($"PushRequest: {requestValue}");
+            RequestHandler.PushRequest(requestValue);
+        }
+
+        async UniTask<TRequest> IRequestConsumer<TRequest>.WaitRequestAndConsumeAsync(CancellationToken cancellationToken)
+        {
+            Logger.LogInformation("Start WaitRequestAndConsumeAsync");
+            var request = await  RequestHandler.WaitRequestAndConsumeAsync(cancellationToken);
+            Logger.LogInformation($"End WaitRequestAndConsumeAsync request:{request}");
+            return request;
+        }
+    }
+}
+#endif