Init

Prefab/Handler/IHandlerContextAccessor.cs

@@ -0,0 +1,66 @@
+namespace Prefab.Handler;
+
+/// <summary>
+/// Provides access to the current handler context for the executing operation.
+/// </summary>
+/// <remarks>Implementations of this interface allow components to retrieve or temporarily override the current
+/// HandlerContext within a given scope. This is typically used to flow contextual information, such as user or request
+/// data, through asynchronous or nested operations.</remarks>
+public interface IHandlerContextAccessor
+{
+    /// <summary>
+    /// Gets the current handler context for the ongoing operation, if one is available.
+    /// </summary>
+    HandlerContext? Current { get; }
+
+    /// <summary>
+    /// Sets the specified handler context as the current context for the duration of the returned disposable object's
+    /// lifetime.
+    /// </summary>
+    /// <remarks>Use the returned IDisposable in a using statement to ensure the previous context is restored
+    /// even if an exception occurs.</remarks>
+    /// <param name="handlerContext">The handler context to set as current. Cannot be null.</param>
+    /// <returns>An IDisposable that, when disposed, restores the previous handler context.</returns>
+    IDisposable Set(HandlerContext handlerContext);
+}
+
+/// <inheritdoc cref="IHandlerContextAccessor"/>
+public sealed class HandlerContextAccessor : IHandlerContextAccessor
+{
+    private static readonly AsyncLocal<HandlerContext?> CurrentContext = new();
+
+    /// <inheritdoc cref="IHandlerContextAccessor"/>
+    public HandlerContext? Current => CurrentContext.Value;
+
+    /// <inheritdoc cref="IHandlerContextAccessor"/>
+    public IDisposable Set(HandlerContext handlerContext)
+    {
+        var previous = CurrentContext.Value;
+
+        CurrentContext.Value = handlerContext;
+
+        return new Scope(() => CurrentContext.Value = previous);
+    }
+    
+    /// <summary>
+    /// Provides a mechanism for executing a specified delegate when the scope is disposed, typically used to restore
+    /// state or perform cleanup actions.
+    /// </summary>
+    /// <remarks>This type is intended for use with the 'using' statement to ensure that the specified
+    /// delegate is executed exactly once when the scope ends. The delegate is not invoked if Dispose is called more
+    /// than once.</remarks>
+    /// <param name="restore">The delegate to invoke when the scope is disposed. Cannot be null.</param>
+    private sealed class Scope(Action restore) : IDisposable
+    {
+        private bool _done;
+
+        public void Dispose()
+        {
+            if(_done)
+                return;
+
+            _done = true;
+            restore();
+        }
+    }
+}