ResultToProblem 2.0.3

ResultToProblem

https://www.nuget.org/packages/ResultToProblem/

ResultToProblem is a .NET library that extends the Result pattern and simplifies the conversion of domain results into standard HTTP responses using ProblemDetails.

Its purpose is to streamline error handling in ASP.NET Core applications, maintaining a clean and consistent style across endpoints and controllers.

Installation

Install the package from NuGet:

bash dotnet add package ResultToProblem

Basic Usage

Examples in an ASP.NET Core project

Minimal API endpoint using ResultToProblem:

Example 1:

program.cs:

using ResultToProblem.Domain.Common;
using ResultToProblem.Domain.Enums;
using ResultToProblem.Api.Extensions;

//....

app.MapGet("/", () =>
{
    var random = new Random();
    var temperature = random.Next(-10, 40);

    if (temperature < -5)
    {
        var result = Result.Failure(
            code: "WEATHER_SENSOR_FAILURE",
            message: "Temperature sensor error",            
            type: ErrorType.Unexpected
        );

        return Results.Problem(result.ToProblemDetails());
    }

    var success = Result.Success($"Today's temperature is {temperature}°C");
    return Results.Ok(success.Value);
});

app.Run();

Example 2:

program.cs:

using ResultToProblem.Domain.Common;
using ResultToProblem.Domain.Enums;
using ResultToProblem.Api.Extensions;

//....

app.MapGet("/", () =>
{
    var random = new Random();
    var temperature = random.Next(-10, 40);

    if (temperature < -5)
    {
        var result = Result.Failure(
            Error.Unexpected("WEATHER_SENSOR_FAILURE", "Temperature sensor error")
        );

        return Results.Problem(result.ToProblemDetails());
    }

    var success = Result.Success($"Today's temperature is {temperature}°C");
    return Results.Ok(success.Value);
});

app.Run();

Other combinations:

Error.Conflict("DUPLICATE_ENTRY", "User already exists")
Error.NotFound("USER_NOT_FOUND", "User record not found")
Error.Validation("INVALID_INPUT", "Temperature must be above zero")

ToValidationProblemDetails() extension for validation errors:

app.MapPost("/users", (UserDTO dto) =>
{
    var errors = new Dictionary<string, string[]>();

    if (string.IsNullOrWhiteSpace(dto.Email))
        errors.Add("Email", new[] { "Email cannot be empty" });
    else if (!Regex.IsMatch(dto.Email, @"^[^@\s]+@[^@\s]+\.[^@\s]+$"))
        errors.Add("Email", new[] { "Email format is invalid" });

    if (string.IsNullOrWhiteSpace(dto.Name))
        errors.Add("Name", new[] { "Name is required" });
    else if (dto.Name.Length < 3)
        errors.Add("Name", new[] { "Name must be at least 3 characters" });

    if (dto.Age < 18 || dto.Age > 120)
        errors.Add("Age", new[] { "Age must be between 18 and 120" });

    if (errors.Any())
    {
        var result = Result.Failure(
            message: "Validation failed",
            code: "USER_VALIDATION_ERROR",
            type: ErrorType.Validation,
            validationErrors: errors
        );

        return Results.ValidationProblem(result.ToValidationProblemDetails().Errors);
    }

    return Results.Ok(new { Message = "User created successfully" });
});

Using a centralized validator:

UserValidator.cs:

public static class UserValidator
{
    public static Result Validate(UserDTO dto)
    {
        var errors = new Dictionary<string, string[]>();

        if (string.IsNullOrWhiteSpace(dto.Email))
            errors.Add("Email", new[] { "Email cannot be empty" });
        else if (!Regex.IsMatch(dto.Email, @"^[^@\s]+@[^@\s]+\.[^@\s]+$"))
            errors.Add("Email", new[] { "Email format is invalid" });

        if (string.IsNullOrWhiteSpace(dto.Name))
            errors.Add("Name", new[] { "Name is required" });
        else if (dto.Name.Length < 3)
            errors.Add("Name", new[] { "Name must be at least 3 characters" });

        if (dto.Age < 18 || dto.Age > 120)
            errors.Add("Age", new[] { "Age must be between 18 and 120" });

        return errors.Any()
            ? Result.Failure("Validation failed", "USER_VALIDATION_ERROR", ErrorType.Validation, errors)
            : Result.Success(dto);
    }
}

program.cs:

app.MapPost("/users", (UserDTO dto) =>
{
    var result = UserValidator.Validate(dto);
    return result.IsSuccess
        ? Results.Ok(new { Message = "User created successfully" })
        : Results.ValidationProblem(result.ToValidationProblemDetails().Errors);
});

Using a centralized validator with a middleware:

UserValidator.cs:

public static class UserValidator
{
    public static Result Validate(UserDTO dto)
    {
        var errors = new Dictionary<string, string[]>();

        if (string.IsNullOrWhiteSpace(dto.Email))
            errors.Add("Email", new[] { "Email cannot be empty" });
        else if (!Regex.IsMatch(dto.Email, @"^[^@\s]+@[^@\s]+\.[^@\s]+$"))
            errors.Add("Email", new[] { "Email format is invalid" });

        if (string.IsNullOrWhiteSpace(dto.Name))
            errors.Add("Name", new[] { "Name is required" });
        else if (dto.Name.Length < 3)
            errors.Add("Name", new[] { "Name must be at least 3 characters" });

        if (dto.Age < 18 || dto.Age > 120)
            errors.Add("Age", new[] { "Age must be between 18 and 120" });

        return errors.Any()
            ? Result.Failure("Validation failed", "USER_VALIDATION_ERROR", ErrorType.Validation, errors)
            : Result.Success(dto);
    }
}

program.cs:

//Middleware Register
app.UseMiddleware<ResultMiddleware>();
 
app.MapPost("/users", (HttpContext ctx, UserDTO dto) =>
{
    var result = UserValidator.Validate(dto);

    // Store the result for middleware to process
    ctx.Items["Result"] = result;

    // Endpoint doesn’t return JSON directly — middleware handles it
    return Results.Empty;
});

✨ Features

• Automatically converts Result objects into ProblemDetails
• Standardized handling for common errors: NotFound, Validation, Conflict, Unexpected
• Easy-to-use extensions for minimal API endpoints
• Compatible with Clean Architecture and Domain-Driven Design

⚖️ License

This project is freely available under the MIT license.
You may use it without restrictions, as long as you retain the reference to the original license.