Add DI extensions for exception handling

Introduces DependencyInjectionExtensions.cs to provide registration helpers for exception handling services and MediatR pipeline integration. Updates README with usage examples for AddCleanArchitectureExceptions and AddCleanArchitectureExceptionsPipeline.

Author: mheidari988

src/CleanArchitecture.Extensions.Exceptions/DependencyInjectionExtensions.cs

@@ -0,0 +1,58 @@
+using CleanArchitecture.Extensions.Exceptions.Behaviors;
+using CleanArchitecture.Extensions.Exceptions.Catalog;
+using CleanArchitecture.Extensions.Exceptions.Options;
+using CleanArchitecture.Extensions.Exceptions.Redaction;
+using MediatR;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+
+namespace CleanArchitecture.Extensions.Exceptions;
+
+/// <summary>
+/// Registration helpers for CleanArchitecture.Extensions.Exceptions.
+/// </summary>
+public static class DependencyInjectionExtensions
+{
+    /// <summary>
+    /// Registers exception handling services (catalog, redactor, options).
+    /// </summary>
+    /// <param name="services">Service collection.</param>
+    /// <param name="configureHandling">Optional callback to configure <see cref="ExceptionHandlingOptions"/>.</param>
+    /// <param name="configureCatalog">Optional callback to configure <see cref="ExceptionCatalogOptions"/>.</param>
+    public static IServiceCollection AddCleanArchitectureExceptions(
+        this IServiceCollection services,
+        Action<ExceptionHandlingOptions>? configureHandling = null,
+        Action<ExceptionCatalogOptions>? configureCatalog = null)
+    {
+        ArgumentNullException.ThrowIfNull(services);
+
+        var handlingBuilder = services.AddOptions<ExceptionHandlingOptions>();
+        if (configureHandling is not null)
+        {
+            handlingBuilder.Configure(configureHandling);
+        }
+
+        var catalogBuilder = services.AddOptions<ExceptionCatalogOptions>();
+        if (configureCatalog is not null)
+        {
+            catalogBuilder.Configure(configureCatalog);
+        }
+
+        services.TryAddSingleton<IExceptionCatalog, ExceptionCatalog>();
+        services.TryAddSingleton<ExceptionRedactor>();
+
+        return services;
+    }
+
+    /// <summary>
+    /// Adds the MediatR exception wrapping behavior to the pipeline.
+    /// </summary>
+    public static MediatRServiceConfiguration AddCleanArchitectureExceptionsPipeline(
+        this MediatRServiceConfiguration configuration)
+    {
+        ArgumentNullException.ThrowIfNull(configuration);
+
+        configuration.AddOpenBehavior(typeof(ExceptionWrappingBehavior<,>));
+        return configuration;
+    }
+}

src/CleanArchitecture.Extensions.Exceptions/README.md

@@ -20,20 +20,37 @@ Check NuGet.org for the latest stable or preview version before installing.
 Register the behavior in the MediatR pipeline (after validation, before performance logging) and tune the options if needed:
 
 ```csharp
-using CleanArchitecture.Extensions.Exceptions.Behaviors;
+using System.Net;
+using CleanArchitecture.Extensions.Exceptions;
 using CleanArchitecture.Extensions.Exceptions.Options;
+using CleanArchitecture.Extensions.Exceptions.BaseTypes;
+using CleanArchitecture.Extensions.Exceptions.Catalog;
 using MediatR;
 
-services.AddTransient(typeof(IPipelineBehavior<,>), typeof(ExceptionWrappingBehavior<,>));
-
-services.Configure<ExceptionHandlingOptions>(options =>
+services.AddCleanArchitectureExceptions(options =>
 {
     options.IncludeExceptionDetails = false;
     options.RethrowExceptionTypes.Add(typeof(OperationCanceledException));
     options.EnvironmentName = env.EnvironmentName; // include details/stack in configured environments (e.g., Development)
     options.IncludeStackTrace = false;
     options.StatusCodeOverrides["ERR.DOMAIN.GENERIC"] = HttpStatusCode.UnprocessableEntity;
 });
+
+services.AddMediatR(cfg =>
+{
+    cfg.RegisterServicesFromAssemblyContaining<Program>();
+    cfg.AddCleanArchitectureExceptionsPipeline();
+});
+
+// Optional: configure catalog overrides
+services.Configure<ExceptionCatalogOptions>(catalog =>
+{
+    catalog.Descriptors.Add(new ExceptionDescriptor(
+        typeof(CustomDomainException),
+        "ERR.DOMAIN.CUSTOM",
+        "Custom domain failure",
+        ExceptionSeverity.Error));
+});
 ```
 
 When handlers return `Result`/`Result<T>`, the behavior converts catalogued exceptions into failure results so controllers can return `ProblemDetails` consistently. Configure redaction and retry classification via `ExceptionHandlingOptions` and the catalog if you need stricter policies.