ErrorOrDotNetFramework 1.9.0

<div align="center">

This package is a back ported version of ErrorOr to .NET Framework 4.8 to facilitate using it on legacy code projects. The goal is to be able to use it on legacy projects and enable upgrade to modern versions of .NET that can use the original library without needing code modifications.

<img src="assets/icon.png" alt="drawing" width="700px"/></br>

A simple, fluent discriminated union of an error or a result.

dotnet add package ErrorOrDotNetFramework

</div>

• Give it a star ⭐!
• Getting Started 🏃
  • Replace throwing exceptions with ErrorOr<T>
  • Return Multiple Errors When Needed
• Creating an ErrorOr instance
  • Using implicit conversion
  • Using The ErrorOrFactory
  • Using The ToErrorOr Extension Method
• Properties
  • IsError
  • Value
  • Errors
  • FirstError
  • ErrorsOrEmptyList
• Methods
  • Match
    • Match
    • MatchAsync
    • MatchFirst
    • MatchFirstAsync
  • Switch
    • Switch
    • SwitchAsync
    • SwitchFirst
    • SwitchFirstAsync
  • Then
    • Then
    • ThenAsync
    • Mixing Then and ThenAsync
  • Else
    • Else
    • ElseAsync
• Mixing Features (Then, Else, Switch, Match)
• Error Types
  • Built in error types
  • Custom error types
• Built in result types (Result.Success, ..)
• Organizing Errors
• Mediator + FluentValidation + ErrorOr 🤝
• Contribution 🤲
• Credits 🙏
• License 🪪

Give it a star ⭐!

Loving it? Show your support by giving this project a star!

Getting Started 🏃

Replace throwing exceptions with ErrorOr<T>

This 👇

public float Divide(int a, int b)
{
    if (b == 0)
    {
        throw new Exception("Cannot divide by zero");
    }

    return a / b;
}

try
{
    var result = Divide(4, 2);
    Console.WriteLine(result * 2); // 4
}
catch (Exception e)
{
    Console.WriteLine(e.Message);
    return;
}

Turns into this 👇

public ErrorOr<float> Divide(int a, int b)
{
    if (b == 0)
    {
        return Error.Unexpected(description: "Cannot divide by zero");
    }

    return a / b;
}

var result = Divide(4, 2);

if (result.IsError)
{
    Console.WriteLine(result.FirstError.Description);
    return;
}

Console.WriteLine(result.Value * 2); // 4

Or, using Then/Else and Switch/Match, you can do this 👇

Divide(4, 2)
    .Then(val => val * 2)
    .SwitchFirst(
        onValue: Console.WriteLine, // 4
        onFirstError: error => Console.WriteLine(error.Description));

Return Multiple Errors When Needed

Internally, the ErrorOr object has a list of Errors, so if you have multiple errors, you don't need to compromise and have only the first one.

public class User(string _name)
{
    public static ErrorOr<User> Create(string name)
    {
        List<Error> errors = [];

        if (name.Length < 2)
        {
            errors.Add(Error.Validation(description: "Name is too short"));
        }

        if (name.Length > 100)
        {
            errors.Add(Error.Validation(description: "Name is too long"));
        }

        if (string.IsNullOrWhiteSpace(name))
        {
            errors.Add(Error.Validation(description: "Name cannot be empty or whitespace only"));
        }

        if (errors.Count > 0)
        {
            return errors;
        }

        return new User(name);
    }
}

Creating an ErrorOr instance

Using implicit conversion

There are implicit converters from TResult, Error, List<Error> to ErrorOr<TResult>

ErrorOr<int> result = 5;
ErrorOr<int> result = Error.Unexpected();
ErrorOr<int> result = [Error.Validation(), Error.Validation()];

public ErrorOr<int> IntToErrorOr()
{
    return 5;
}

public ErrorOr<int> SingleErrorToErrorOr()
{
    return Error.Unexpected();
}

public ErrorOr<int> MultipleErrorsToErrorOr()
{
    return [
        Error.Validation(description: "Invalid Name"),
        Error.Validation(description: "Invalid Last Name")
    ];
}

Using The ErrorOrFactory

ErrorOr<int> result = ErrorOrFactory.From(5);
ErrorOr<int> result = ErrorOrFactory.From<int>(Error.Unexpected());
ErrorOr<int> result = ErrorOrFactory.From<int>([Error.Validation(), Error.Validation()]);

public ErrorOr<int> GetValue()
{
    return ErrorOrFactory.From(5);
}

public ErrorOr<int> SingleErrorToErrorOr()
{
    return ErrorOrFactory.From<int>(Error.Unexpected());
}

public ErrorOr<int> MultipleErrorsToErrorOr()
{
    return ErrorOrFactory.From([
        Error.Validation(description: "Invalid Name"),
        Error.Validation(description: "Invalid Last Name")
    ]);
}

Using The ToErrorOr Extension Method

ErrorOr<int> result = 5.ToErrorOr();
ErrorOr<int> result = Error.Unexpected().ToErrorOr<int>();
ErrorOr<int> result = new[] { Error.Validation(), Error.Validation() }.ToErrorOr<int>();

Properties

IsError

ErrorOr<int> result = User.Create();

if (result.IsError)
{
    // the result contains one or more errors
}

Value

ErrorOr<int> result = User.Create();

if (!result.IsError) // the result contains a value
{
    Console.WriteLine(result.Value);
}

Errors

ErrorOr<int> result = User.Create();

if (result.IsError)
{
    result.Errors // contains the list of errors that occurred
        .ForEach(error => Console.WriteLine(error.Description));
}

FirstError

ErrorOr<int> result = User.Create();

if (result.IsError)
{
    var firstError = result.FirstError; // only the first error that occurred
    Console.WriteLine(firstError == result.Errors[0]); // true
}

ErrorsOrEmptyList

ErrorOr<int> result = User.Create();

if (result.IsError)
{
    result.ErrorsOrEmptyList // List<Error> { /* one or more errors */  }
    return;
}

result.ErrorsOrEmptyList // List<Error> { }

Methods

Match

The Match method receives two functions, onValue and onError, onValue will be invoked if the result is success, and onError is invoked if the result is an error.

Match

string foo = result.Match(
    value => value,
    errors => $"{errors.Count} errors occurred.");

MatchAsync

string foo = await result.MatchAsync(
    value => Task.FromResult(value),
    errors => Task.FromResult($"{errors.Count} errors occurred."));

MatchFirst

The MatchFirst method receives two functions, onValue and onError, onValue will be invoked if the result is success, and onError is invoked if the result is an error.

Unlike Match, if the state is error, MatchFirst's onError function receives only the first error that occurred, not the entire list of errors.

string foo = result.MatchFirst(
    value => value,
    firstError => firstError.Description);

MatchFirstAsync

string foo = await result.MatchFirstAsync(
    value => Task.FromResult(value),
    firstError => Task.FromResult(firstError.Description));

Switch

The Switch method receives two actions, onValue and onError, onValue will be invoked if the result is success, and onError is invoked if the result is an error.

Switch

result.Switch(
    value => Console.WriteLine(value),
    errors => Console.WriteLine($"{errors.Count} errors occurred."));

SwitchAsync

await result.SwitchAsync(
    value => { Console.WriteLine(value); return Task.CompletedTask; },
    errors => { Console.WriteLine($"{errors.Count} errors occurred."); return Task.CompletedTask; });

SwitchFirst

The SwitchFirst method receives two actions, onValue and onError, onValue will be invoked if the result is success, and onError is invoked if the result is an error.

Unlike Switch, if the state is error, SwitchFirst's onError function receives only the first error that occurred, not the entire list of errors.

result.SwitchFirst(
    value => Console.WriteLine(value),
    firstError => Console.WriteLine(firstError.Description));

SwitchFirstAsync

await result.SwitchFirstAsync(
    value => { Console.WriteLine(value); return Task.CompletedTask; },
    firstError => { Console.WriteLine(firstError.Description); return Task.CompletedTask; });

Then

Then

Then receives an action or a function, and invokes it only if the result is not an error.

ErrorOr<int> foo = result
    .Then(val => val * 2);

Multiple Then methods can be chained together.

ErrorOr<string> foo = result
    .Then(val => val * 2)
    .Then(val => $"The result is {val}");

If any of the methods return an error, the chain will break and the errors will be returned.

ErrorOr<int> Foo() => Error.Unexpected();

ErrorOr<string> foo = result
    .Then(val => val * 2)
    .Then(_ => GetAnError())
    .Then(val => $"The result is {val}") // this function will not be invoked
    .Then(val => $"The result is {val}"); // this function will not be invoked

ThenAsync

ThenAsync receives an asynchronous action or function, and invokes it only if the result is not an error.

ErrorOr<string> foo = await result
    .ThenAsync(val => Task.Delay(val))
    .ThenAsync(val => Task.FromResult($"The result is {val}"));

Mixing Then and ThenAsync

You can mix Then and ThenAsync methods together.

ErrorOr<string> foo = await result
    .ThenAsync(val => Task.Delay(val))
    .Then(val => Console.WriteLine($"Finsihed waiting {val} seconds."))
    .ThenAsync(val => Task.FromResult(val * 2))
    .Then(val => $"The result is {val}");

Else

Else receives a value or a function. If the result is an error, Else will return the value or invoke the function. Otherwise, it will return the value of the result.

Else

ErrorOr<string> foo = result
    .Else("fallback value");

ErrorOr<string> foo = result
    .Else(errors => $"{errors.Count} errors occurred.");

ElseAsync

ErrorOr<string> foo = await result
    .ElseAsync(Task.FromResult("fallback value"));

ErrorOr<string> foo = await result
    .ElseAsync(errors => Task.FromResult($"{errors.Count} errors occurred."));

Mixing Features (Then, Else, Switch, Match)

You can mix Then, Else, Switch and Match methods together.

ErrorOr<string> foo = await result
    .ThenAsync(val => Task.Delay(val))
    .Then(val => Console.WriteLine($"Finsihed waiting {val} seconds."))
    .ThenAsync(val => Task.FromResult(val * 2))
    .Then(val => $"The result is {val}")
    .Else(errors => Error.Unexpected())
    .MatchFirst(
        value => value,
        firstError => $"An error occurred: {firstError.Description}");

Error Types

Each Error instance has a Type property, which is an enum value that represents the type of the error.

Built in error types

The following error types are built in:

public enum ErrorType
{
    Failure,
    Unexpected,
    Validation,
    Conflict,
    NotFound,
    Unauthorized,
}

Each error type has a static method that creates an error of that type. For example:

var error = Error.NotFound();

optionally, you can pass a code, description and metadata to the error:

var error = Error.Unexpected(
    code: "User.ShouldNeverHappen",
    description: "A user error that should never happen",
    metadata: new Dictionary<string, object>
    {
        { "user", user },
    });

The ErrorType enum is a good way to categorize errors.

Custom error types

You can create your own error types if you would like to categorize your errors differently.

A custom error type can be created with the Custom static method

public static class MyErrorTypes
{
    const int ShouldNeverHappen = 12;
}

var error = Error.Custom(
    type: MyErrorTypes.ShouldNeverHappen,
    code: "User.ShouldNeverHappen",
    description: "A user error that should never happen");

You can use the Error.NumericType method to retrieve the numeric type of the error.

var errorMessage = Error.NumericType switch
{
    MyErrorType.ShouldNeverHappen => "Consider replacing dev team",
    _ => "An unknown error occurred.",
};

Built in result types (Result.Success, ..)

There are a few built in result types:

ErrorOr<Success> result = Result.Success;
ErrorOr<Created> result = Result.Created;
ErrorOr<Updated> result = Result.Updated;
ErrorOr<Deleted> result = Result.Deleted;

Which can be used as following

ErrorOr<Deleted> DeleteUser(Guid id)
{
    var user = await _userRepository.GetByIdAsync(id);
    if (user is null)
    {
        return Error.NotFound(description: "User not found.");
    }

    await _userRepository.DeleteAsync(user);
    return Result.Deleted;
}

Organizing Errors

A nice approach, is creating a static class with the expected errors. For example:

public static partial class DivisionErrors
{
    public static Error CannotDivideByZero = Error.Unexpected(
        code: "Division.CannotDivideByZero",
        description: "Cannot divide by zero.");
}

Which can later be used as following 👇

public ErrorOr<float> Divide(int a, int b)
{
    if (b == 0)
    {
        return DivisionErrors.CannotDivideByZero;
    }

    return a / b;
}

Mediator + FluentValidation + ErrorOr 🤝

A common approach when using MediatR is to use FluentValidation to validate the request before it reaches the handler.

Usually, the validation is done using a Behavior that throws an exception if the request is invalid.

Using ErrorOr, we can create a Behavior that returns an error instead of throwing an exception.

This plays nicely when the project uses ErrorOr, as the layer invoking the Mediator, similar to other components in the project, simply receives an ErrorOr and can handle it accordingly.

Here is an example of a Behavior that validates the request and returns an error if it's invalid 👇

public class ValidationBehavior<TRequest, TResponse>(IValidator<TRequest>? validator = null)
    : IPipelineBehavior<TRequest, TResponse>
        where TRequest : IRequest<TResponse>
        where TResponse : IErrorOr
{
    private readonly IValidator<TRequest>? _validator = validator;

    public async Task<TResponse> Handle(
        TRequest request,
        RequestHandlerDelegate<TResponse> next,
        CancellationToken cancellationToken)
    {
        if (_validator is null)
        {
            return await next();
        }

        var validationResult = await _validator.ValidateAsync(request, cancellationToken);

        if (validationResult.IsValid)
        {
            return await next();
        }

        var errors = validationResult.Errors
            .ConvertAll(error => Error.Validation(
                code: error.PropertyName,
                description: error.ErrorMessage));

        return (dynamic)errors;
    }
}

Contribution 🤲

If you have any questions, comments, or suggestions, please open an issue or create a pull request 🙂

License 🪪

This project is licensed under the terms of the MIT license.