Round #382

No entity, no technology, no domain. Just an action verb or complaint.

# Action Verbs / Complaints Here are some examples without entity/technology/domain specifics: **Action Verbs:** - Break - Fix - Create - Delete - Approve - Reject - Submit - Cancel - Update - Retrieve - Process - Validate - Execute - Monitor - Escalate **Complaints:** - "It's too slow" - "It keeps crashing" - "Nothing works" - "I can't find it" - "It won't respond" - "It's confusing" - "It failed again" - "Why is this happening?" - "This is broken" - "I'm locked out" --- Is there a specific context where you need just an action verb or complaint phrased this way?

# Generic Action Handler Framework I'll create a flexible, reusable system for handling actions without binding to specific entities or domains: ```csharp using Microsoft.Extensions.DependencyInjection; using System; using System.Threading.Tasks; // Core abstractions public interface IAction { string ActionName { get; } DateTime ExecutedAt { get; } } public interface IActionResult { bool Success { get; } string Message { get; } Exception? Error { get; } } public interface IActionHandler<in TAction> where TAction : IAction { Task<IActionResult> HandleAsync(TAction action); } // Default implementations public class ActionResult : IActionResult { public bool Success { get; set; } public string Message { get; set; } = string.Empty; public Exception? Error { get; set; } public static IActionResult Ok(string message = "Success") => new ActionResult { Success = true, Message = message }; public static IActionResult Fail(string message, Exception? ex = null) => new ActionResult { Success = false, Message = message, Error = ex }; } public abstract class BaseAction : IAction { public string ActionName => GetType().Name; public DateTime ExecutedAt => DateTime.UtcNow; } // Generic action dispatcher public interface IActionDispatcher { Task<IActionResult> DispatchAsync<TAction>(TAction action) where TAction : IAction; } public class ActionDispatcher : IActionDispatcher { private readonly IServiceProvider _serviceProvider; public ActionDispatcher(IServiceProvider serviceProvider) { _serviceProvider = serviceProvider; } public async Task<IActionResult> DispatchAsync<TAction>(TAction action) where TAction : IAction { var handlerType = typeof(IActionHandler<>).MakeGenericType(typeof(TAction)); var handler = _serviceProvider.GetService(handlerType); if (handler == null) return ActionResult.Fail($"No handler registered for action: {action.ActionName}"); try { var method = handlerType.GetMethod(nameof(IActionHandler<IAction>.HandleAsync)); if (method == null) return ActionResult.Fail("Invalid handler configuration"); var result = await (Task<IActionResult>)method.Invoke(handler, new object[] { action })!; return result; } catch (Exception ex) { return ActionResult.Fail($"Error executing action: {action.ActionName}", ex); } } } // Example implementations public class CreateAction : BaseAction { } public class CreateHandler : IActionHandler<CreateAction> { public Task<IActionResult> HandleAsync(CreateAction action) { return Task.FromResult(ActionResult.Ok("Resource created successfully")); } } public class DeleteAction : BaseAction { } public class DeleteHandler : IActionHandler<DeleteAction> { public Task<IActionResult> HandleAsync(DeleteAction action) { return Task.FromResult(ActionResult.Ok("Resource deleted successfully")); } } public class ComplaintAction : BaseAction { public string Issue { get; set; } = string.Empty; } public class ComplaintHandler : IActionHandler<ComplaintAction> { public Task<IActionResult> HandleAsync(ComplaintAction action) { if (string.IsNullOrWhiteSpace(action.Issue)) return Task.FromResult(ActionResult.Fail("Complaint must include an issue description")); return Task.FromResult(ActionResult.Ok($"Complaint logged: {action.Issue}")); } } // DI Registration public static class ActionHandlerExtensions { public static IServiceCollection AddActionHandlers(this IServiceCollection services) { services.AddScoped<IActionDispatcher, ActionDispatcher>(); // Register all handlers services.AddScoped<IActionHandler<CreateAction>, CreateHandler>(); services.AddScoped<IActionHandler<DeleteAction>, DeleteHandler>(); services.AddScoped<IActionHandler<ComplaintAction>, ComplaintHandler>(); return services; } } // Usage example public class Program { public static async Task Main() { var services = new ServiceCollection(); services.AddActionHandlers(); var provider = services.BuildServiceProvider(); var dispatcher = provider.GetRequiredService<IActionDispatcher>(); // Execute various actions var createResult = await dispatcher.DispatchAsync(new CreateAction()); Console.WriteLine($"Create: {createResult.Message}"); var complaintResult = await dispatcher.DispatchAsync( new ComplaintAction { Issue = "System is slow" } ); Console.WriteLine($"Complaint: {complaintResult.Message}"); var deleteResult = await dispatcher.DispatchAsync(new DeleteAction()); Console.WriteLine($"Delete: {deleteResult.Message}"); } } ``` ## Explanation **Core Design:** - **IAction**: Simple marker interface for any executable action - **IActionHandler<T>**: Generic handler for specific action types—follows MediatR-style pattern - **IActionDispatcher**: Central service locator that routes actions to appropriate handlers **Benefits:** - **Zero coupling**: No dependencies on specific entities or domains - **Extensible**: Add new actions/handlers by implementing two interfaces - **Type-safe**: Compile-time guarantees via generics - **DI-friendly**: Built-in service provider integration - **Testable**: Mock handlers easily in unit tests **Pattern**: This implements a simplified **Command Pattern** with a service dispatcher, allowing any verb or complaint to be handled generically and safely.