Enable Nullable for all projects

Changelog.md

@@ -1,5 +1,8 @@
 # Changelog
 
+## v.0.25.0
+- Enable `Nullable` for all projects.
+
 ## v.0.24.4
 
 - Improve XML comments in the codebase.

src/Directory.Build.props

@@ -5,13 +5,13 @@
         <LangVersion>latest</LangVersion>
         <Authors>A. Shafie</Authors>
         <PackageTags>mediator;cqrs</PackageTags>
-        <VersionPrefix>0.24.4</VersionPrefix>
+        <VersionPrefix>0.25.0</VersionPrefix>
         <PackageIcon>icon.png</PackageIcon>
         <Description>LiteBus is an easy-to-use and ambitious in-process mediator providing the foundation to implement Command Query Separation (CQS). It is implemented with minimal reflection and instead utilizes covariance and contravariance to provide its core functionality.</Description>
         <PackageProjectUrl>https://github.com/litenova/LiteBus</PackageProjectUrl>
         <RepositoryUrl>https://github.com/litenova/LiteBus</RepositoryUrl>
         <PackageLicenseExpression>MIT</PackageLicenseExpression>
-        <Nullable>disable</Nullable>
+        <Nullable>enable</Nullable>
         <PackageReadmeFile>README.md</PackageReadmeFile>
         <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
     </PropertyGroup>

src/LiteBus.Commands.Abstractions/CommandMediationSettings.cs

@@ -1,5 +1,3 @@
-#nullable enable
-
 using System.Collections.Generic;
 
 namespace LiteBus.Commands.Abstractions;

src/LiteBus.Commands.Abstractions/Extensions/CommandMediatorExtensions.cs

@@ -42,9 +42,9 @@ public static Task SendAsync(this ICommandMediator commandMediator,
     /// var result = await commandMediator.SendAsync(myCommand, cancellationToken);
     /// </code>
     /// </example>
-    public static Task<TCommandResult> SendAsync<TCommandResult>(this ICommandMediator commandMediator,
-                                                                 ICommand<TCommandResult> command,
-                                                                 CancellationToken cancellationToken = default)
+    public static Task<TCommandResult?> SendAsync<TCommandResult>(this ICommandMediator commandMediator,
+                                                                  ICommand<TCommandResult> command,
+                                                                  CancellationToken cancellationToken = default)
     {
         return commandMediator.SendAsync(command, null, cancellationToken);
     }
@@ -73,7 +73,7 @@ public static Task SendAsync(this ICommandMediator commandMediator,
             {
                 Filters =
                 {
-                    Tags = new[] { tag }
+                    Tags = [tag]
                 }
             },
             cancellationToken);
@@ -94,17 +94,17 @@ public static Task SendAsync(this ICommandMediator commandMediator,
     /// var result = await commandMediator.SendAsync(myCommand, "UserAction", cancellationToken);
     /// </code>
     /// </example>
-    public static Task<TCommandResult> SendAsync<TCommandResult>(this ICommandMediator commandMediator,
-                                                                 ICommand<TCommandResult> command,
-                                                                 string tag,
-                                                                 CancellationToken cancellationToken = default)
+    public static Task<TCommandResult?> SendAsync<TCommandResult>(this ICommandMediator commandMediator,
+                                                                  ICommand<TCommandResult> command,
+                                                                  string tag,
+                                                                  CancellationToken cancellationToken = default)
     {
         return commandMediator.SendAsync(command,
             new CommandMediationSettings
             {
                 Filters =
                 {
-                    Tags = new[] { tag }
+                    Tags = [tag]
                 }
             },
             cancellationToken);

src/LiteBus.Commands.Abstractions/ICommandMediator.cs

@@ -1,5 +1,4 @@
-#nullable enable
-using System.Threading;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace LiteBus.Commands.Abstractions;
@@ -46,5 +45,7 @@ public interface ICommandMediator
     /// is executed, including pre-handlers, the main handler, post-handlers, and error handlers if exceptions occur.
     /// The result produced by the handler is returned to the caller.
     /// </remarks>
-    Task<TCommandResult> SendAsync<TCommandResult>(ICommand<TCommandResult> command, CommandMediationSettings? commandMediationSettings = null, CancellationToken cancellationToken = default);
+    Task<TCommandResult?> SendAsync<TCommandResult>(ICommand<TCommandResult> command,
+                                                    CommandMediationSettings? commandMediationSettings = null,
+                                                    CancellationToken cancellationToken = default);
 }

src/LiteBus.Commands.Abstractions/ICommandPostHandler[TCommand, TCommandResult].cs

@@ -13,4 +13,6 @@ namespace LiteBus.Commands.Abstractions;
 ///     They have access to both the original command and its result, allowing for operations such as
 ///     result transformation, logging, caching, or other processing that depends on the command outcome.
 /// </remarks>
-public interface ICommandPostHandler<in TCommand, in TCommandResult> : IRegistrableCommandConstruct, IAsyncMessagePostHandler<TCommand, TCommandResult> where TCommand : ICommand<TCommandResult>;
+public interface ICommandPostHandler<in TCommand, in TCommandResult> : IRegistrableCommandConstruct, IAsyncMessagePostHandler<TCommand, TCommandResult>
+    where TCommand : ICommand<TCommandResult>
+    where TCommandResult : notnull;

src/LiteBus.Commands/CommandMediator.cs

@@ -1,6 +1,4 @@
-#nullable enable
-
-using System.Threading;
+using System.Threading;
 using System.Threading.Tasks;
 using LiteBus.Commands.Abstractions;
 using LiteBus.Messaging.Abstractions;
@@ -18,7 +16,7 @@ public CommandMediator(IMessageMediator messageMediator)
     }
 
     public Task SendAsync(ICommand command,
-                          CommandMediationSettings? commandMediationSettings = default,
+                          CommandMediationSettings? commandMediationSettings = null,
                           CancellationToken cancellationToken = default)
     {
         commandMediationSettings ??= new CommandMediationSettings();
@@ -37,15 +35,15 @@ public Task SendAsync(ICommand command,
         return _messageMediator.Mediate(command, options);
     }
 
-    public Task<TCommandResult> SendAsync<TCommandResult>(ICommand<TCommandResult> command,
-                                                          CommandMediationSettings? commandMediationSettings = null,
-                                                          CancellationToken cancellationToken = default)
+    public Task<TCommandResult?> SendAsync<TCommandResult>(ICommand<TCommandResult> command,
+                                                           CommandMediationSettings? commandMediationSettings = null,
+                                                           CancellationToken cancellationToken = default)
     {
         commandMediationSettings ??= new CommandMediationSettings();
-        var mediationStrategy = new SingleAsyncHandlerMediationStrategy<ICommand<TCommandResult>, TCommandResult>();
+        var mediationStrategy = new SingleAsyncHandlerMediationStrategy<ICommand<TCommandResult>, TCommandResult?>();
         var findStrategy = new ActualTypeOrFirstAssignableTypeMessageResolveStrategy();
 
-        var options = new MediateOptions<ICommand<TCommandResult>, Task<TCommandResult>>
+        var options = new MediateOptions<ICommand<TCommandResult>, Task<TCommandResult?>>
         {
             MessageResolveStrategy = findStrategy,
             MessageMediationStrategy = mediationStrategy,

src/LiteBus.Events.Abstractions/EventMediationSettings.cs

@@ -1,5 +1,3 @@
-#nullable enable
-
 using System;
 using System.Collections.Generic;
 

src/LiteBus.Events.Abstractions/Extensions/EventMediatorExtensions.cs

@@ -47,7 +47,7 @@ public static Task PublishAsync(this IEventMediator eventMediator, IEvent @event
             {
                 Filters =
                 {
-                    Tags = new[] { tag }
+                    Tags = [tag]
                 }
             },
             cancellationToken);

src/LiteBus.Events.Abstractions/IEventErrorHandler[TEvent].cs

@@ -13,4 +13,4 @@ namespace LiteBus.Events.Abstractions;
 ///     This allows for implementing specialized error handling strategies for different event types,
 ///     such as custom recovery logic, retry policies, or specific error reporting for critical events.
 /// </remarks>
-public interface IEventErrorHandler<in TEvent> : IAsyncMessageErrorHandler<TEvent, object>, IRegistrableEventConstruct;
+public interface IEventErrorHandler<in TEvent> : IAsyncMessageErrorHandler<TEvent, object>, IRegistrableEventConstruct where TEvent : notnull;

src/LiteBus.Events.Abstractions/IEventHandler[TEvent].cs

@@ -13,4 +13,4 @@ namespace LiteBus.Events.Abstractions;
 ///     execute asynchronously and can perform operations such as updating projections, notifying external
 ///     systems, or triggering additional workflows.
 /// </remarks>
-public interface IEventHandler<in TEvent> : IAsyncMessageHandler<TEvent>, IRegistrableEventConstruct;
+public interface IEventHandler<in TEvent> : IAsyncMessageHandler<TEvent>, IRegistrableEventConstruct where TEvent : notnull;

src/LiteBus.Events.Abstractions/IEventMediator.cs

@@ -1,5 +1,4 @@
-#nullable enable
-using System.Threading;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace LiteBus.Events.Abstractions;

src/LiteBus.Events.Abstractions/IEventPostHandler[TEvent].cs

@@ -12,4 +12,4 @@ namespace LiteBus.Events.Abstractions;
 ///     only to the specified event type. Multiple type-specific post-handlers can be registered for each event type
 ///     and will execute in sequence after the event handlers have processed the event.
 /// </remarks>
-public interface IEventPostHandler<in TEvent> : IAsyncMessagePostHandler<TEvent>, IRegistrableEventConstruct;
+public interface IEventPostHandler<in TEvent> : IAsyncMessagePostHandler<TEvent>, IRegistrableEventConstruct where TEvent : notnull;

src/LiteBus.Events.Abstractions/IEventPreHandler[TEvent].cs

@@ -12,4 +12,4 @@ namespace LiteBus.Events.Abstractions;
 ///     that apply only to the specified event type. Multiple type-specific pre-handlers can be
 ///     registered for each event type and will execute in sequence before the actual event handlers.
 /// </remarks>
-public interface IEventPreHandler<in TEvent> : IAsyncMessagePreHandler<TEvent>, IRegistrableEventConstruct;
+public interface IEventPreHandler<in TEvent> : IAsyncMessagePreHandler<TEvent>, IRegistrableEventConstruct where TEvent : notnull;

src/LiteBus.Events/EventMediator.cs

@@ -1,6 +1,4 @@
-#nullable enable
-
-using System.Threading;
+using System.Threading;
 using System.Threading.Tasks;
 using LiteBus.Events.Abstractions;
 using LiteBus.Events.MediationStrategies;

src/LiteBus.Events/MediationStrategies/AsyncBroadcastMediationStrategy[TMessage].cs

@@ -1,6 +1,4 @@
-#nullable enable
-
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.ExceptionServices;

src/LiteBus.Messaging.Abstractions/Contexts/AmbientExecutionContext.cs

@@ -1,5 +1,6 @@
-#nullable enable
+using System;
 using System.Threading;
+using System.Threading.Tasks;
 
 namespace LiteBus.Messaging.Abstractions;
 
@@ -27,10 +28,99 @@ public static class AmbientExecutionContext
     /// even across asynchronous operations.
     /// 
     /// Setting this property to null clears the ambient execution context.
+    /// 
+    /// Accessing this property when no context has been set will throw a <see cref="NoExecutionContextException"/>.
     /// </remarks>
-    public static IExecutionContext? Current
+    /// <exception cref="NoExecutionContextException">Thrown when attempting to get the current context when none has been set.</exception>
+    public static IExecutionContext Current
     {
-        get => ExecutionContextLocal.Value;
+        get => ExecutionContextLocal.Value ?? throw new NoExecutionContextException();
         set => ExecutionContextLocal.Value = value;
     }
+
+    /// <summary>
+    /// Determines whether a current execution context exists.
+    /// </summary>
+    /// <value>
+    /// <c>true</c> if a current execution context exists; otherwise, <c>false</c>.
+    /// </value>
+    public static bool HasCurrent => ExecutionContextLocal.Value != null;
+
+    /// <summary>
+    /// Gets the current execution context if it exists, or returns null if no context is set.
+    /// </summary>
+    /// <returns>The current execution context or null if no context has been set.</returns>
+    public static IExecutionContext? GetCurrentOrDefault() => ExecutionContextLocal.Value;
+
+    /// <summary>
+    /// Creates a new execution context scope that automatically restores the previous context when disposed.
+    /// </summary>
+    /// <param name="context">The execution context to use within the scope.</param>
+    /// <returns>A disposable scope that restores the previous context when disposed.</returns>
+    /// <example>
+    /// <code>
+    /// // Create a new execution context
+    /// var executionContext = new ExecutionContext(CancellationToken.None);
+    /// 
+    /// // Use the context within a scope
+    /// using (AmbientExecutionContext.CreateScope(executionContext))
+    /// {
+    ///     // Code here has access to the execution context via AmbientExecutionContext.Current
+    ///     var currentContext = AmbientExecutionContext.Current;
+    ///     
+    ///     // Perform operations with the context
+    /// }
+    /// // Previous context (if any) is automatically restored here
+    /// </code>
+    /// </example>
+    public static ExecutionContextScope CreateScope(IExecutionContext context)
+    {
+        return new ExecutionContextScope(context);
+    }
+
+    /// <summary>
+    /// Represents a scope for an execution context that automatically restores the previous context when disposed.
+    /// </summary>
+    /// <remarks>
+    /// This class implements both <see cref="IDisposable"/> and <see cref="IAsyncDisposable"/> to support
+    /// both synchronous and asynchronous usage patterns. When the scope is disposed, the previous execution
+    /// context (if any) is restored.
+    /// </remarks>
+    public sealed class ExecutionContextScope : IDisposable, IAsyncDisposable
+    {
+        private readonly IExecutionContext? _previousContext;
+        private bool _disposed;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ExecutionContextScope"/> class.
+        /// </summary>
+        /// <param name="newContext">The new execution context to set as current during this scope.</param>
+        internal ExecutionContextScope(IExecutionContext newContext)
+        {
+            _previousContext = GetCurrentOrDefault();
+            ExecutionContextLocal.Value = newContext;
+        }
+
+        /// <summary>
+        /// Disposes the scope and restores the previous execution context.
+        /// </summary>
+        public void Dispose()
+        {
+            if (_disposed) return;
+
+            // This assignment is safe because ExecutionContextLocal.Value accepts nullable values
+            ExecutionContextLocal.Value = _previousContext;
+            _disposed = true;
+        }
+
+        /// <summary>
+        /// Asynchronously disposes the scope and restores the previous execution context.
+        /// </summary>
+        /// <returns>A <see cref="ValueTask"/> representing the asynchronous dispose operation.</returns>
+        public ValueTask DisposeAsync()
+        {
+            Dispose();
+            return ValueTask.CompletedTask;
+        }
+    }
 }

src/LiteBus.Messaging.Abstractions/Contexts/Execution/IExecutionContext.cs

@@ -1,4 +1,3 @@
-#nullable enable
 using System.Collections.Generic;
 using System.Threading;
 

src/LiteBus.Messaging.Abstractions/Extensions/MessageContextExtensions.cs

@@ -36,7 +36,7 @@ public static async Task RunAsyncPreHandlers(this IMessageDependencies messageDe
     /// <param name="messageResult">The result of the message handling process, if any.</param>
     /// <param name="exceptionDispatchInfo">The exception that triggered the error handler.</param>
     /// <returns>A Task representing the asynchronous operation.</returns>
-    public static async Task RunAsyncErrorHandlers(this IMessageDependencies messageDependencies, object message, object messageResult, ExceptionDispatchInfo exceptionDispatchInfo)
+    public static async Task RunAsyncErrorHandlers(this IMessageDependencies messageDependencies, object message, object? messageResult, ExceptionDispatchInfo exceptionDispatchInfo)
     {
         if (messageDependencies.ErrorHandlers.Count + messageDependencies.IndirectErrorHandlers.Count == 0)
         {
@@ -61,7 +61,7 @@ public static async Task RunAsyncErrorHandlers(this IMessageDependencies message
     /// <param name="message">The message that has been handled.</param>
     /// <param name="messageResult">The result produced by the message handling process.</param>
     /// <returns>A Task representing the asynchronous operation.</returns>
-    public static async Task RunAsyncPostHandlers(this IMessageDependencies messageDependencies, object message, object messageResult)
+    public static async Task RunAsyncPostHandlers(this IMessageDependencies messageDependencies, object message, object? messageResult)
     {
         foreach (var postHandler in messageDependencies.PostHandlers)
         {

src/LiteBus.Messaging.Abstractions/FindStrategies/ActualTypeOrFirstAssignableTypeMessageResolveStrategy.cs

@@ -1,5 +1,4 @@
-#nullable enable
-using System;
+using System;
 using System.Linq;
 
 namespace LiteBus.Messaging.Abstractions;

src/LiteBus.Messaging.Abstractions/Handler/Error/IAsyncMessageErrorHandler[TMessage, TMessageResult].cs

@@ -1,5 +1,3 @@
-#nullable enable
-
 using System;
 using System.Threading;
 using System.Threading.Tasks;
@@ -13,7 +11,7 @@ namespace LiteBus.Messaging.Abstractions;
 /// </summary>
 /// <typeparam name="TMessage">The type of the message that this error handler is applicable to.</typeparam>
 /// <typeparam name="TMessageResult">The type of the result produced by the message processing.</typeparam>
-public interface IAsyncMessageErrorHandler<in TMessage, in TMessageResult> : IMessageErrorHandler<TMessage, TMessageResult>
+public interface IAsyncMessageErrorHandler<in TMessage, in TMessageResult> : IMessageErrorHandler<TMessage, TMessageResult> where TMessage : notnull
 {
     /// <summary>
     /// Synchronously handles an error encountered in message processing by delegating to an asynchronous method.
@@ -24,7 +22,7 @@ public interface IAsyncMessageErrorHandler<in TMessage, in TMessageResult> : IMe
     /// <returns>A placeholder object returned after handling the error.</returns>
     object IMessageErrorHandler<TMessage, TMessageResult>.HandleError(TMessage message, Exception exception, TMessageResult? messageResult)
     {
-        return HandleErrorAsync(message, messageResult, exception, AmbientExecutionContext.Current?.CancellationToken ?? throw new NoExecutionContextException());
+        return HandleErrorAsync(message, messageResult, exception, AmbientExecutionContext.Current.CancellationToken);
     }
 
     /// <summary>

src/LiteBus.Messaging.Abstractions/Handler/Error/IAsyncMessageErrorHandler[TMessage].cs

@@ -1,5 +1,3 @@
-#nullable enable
-
 using System;
 using System.Threading;
 using System.Threading.Tasks;
@@ -11,7 +9,7 @@ namespace LiteBus.Messaging.Abstractions;
 /// This interface should be implemented to handle exceptions that occur during message processing.
 /// </summary>
 /// <typeparam name="TMessage">The type of the message that this error handler is applicable to.</typeparam>
-public interface IAsyncMessageErrorHandler<in TMessage> : IMessageErrorHandler<TMessage, object>
+public interface IAsyncMessageErrorHandler<in TMessage> : IMessageErrorHandler<TMessage, object> where TMessage : notnull
 {
     /// <summary>
     /// Synchronously handles an error encountered in message processing by delegating to an asynchronous method.
@@ -22,7 +20,7 @@ public interface IAsyncMessageErrorHandler<in TMessage> : IMessageErrorHandler<T
     /// <returns>A placeholder object returned after handling the error.</returns>
     object IMessageErrorHandler<TMessage, object>.HandleError(TMessage message, Exception exception, object? messageResult)
     {
-        return HandleErrorAsync(message, messageResult, exception, AmbientExecutionContext.Current?.CancellationToken ?? throw new NoExecutionContextException());
+        return HandleErrorAsync(message, messageResult, exception, AmbientExecutionContext.Current.CancellationToken);
     }
 
     /// <summary>