BetterErrors 1.3.0-beta

<div align="center">

BetterErrors

A very simple discriminated union of success or error

dotnet add package BetterErrors

</div>

• Getting Started
• A more practical example
• Usage
  • Creating Result<T>
    • Creating Result<T> from IError
  • Checking if the Result<T> is an error
  • Accessing the Result<T> result
    • Accessing the Value
    • Accessing the Error
  • Performing actions based on the Result<T> result
    • Match
    • Switch
    • Map
• Result without a type
• Error Types
  • Built-in Error Types
  • Custom error
    • Benefit of implementing IError interface
    • Benefit of inheriting Error record
    • Examples
• Suggestions and Changes
• Credits

Getting Started

Result<User> GetUser(Guid id = default)
{
    if (id == default)
    {
        return new Error("Id is required");
    }

    return new User(Name: "Amichai");
}

GetUser(...).Switch(
    user => Console.WriteLine(user),
    error => Console.WriteLine(error.Message));

A more practical example

public Result<User> CreateUser(string name, string email)
{
    List<FieldErrorInfo> fieldErrors = new();

    if (name.Length < 2)
    {
        fieldErrors.Add(new("Name", "Name is too short"));
    }

    if (name.Length > 100)
    {
        fieldErrors.Add(new("Name", "Name is too long"));
    }

    if (!validateEmail(email))
    {
        fieldErrors.Add(new("Email", "Email is invalid"));
    }

    if (fieldErrors.Count > 0)
    {
        return new ValidationError("Provided data is not valid", fieldErrors);
    }
    ......User creation logic
}

public async Task<Result<User>> AddUserAsync(string name, string email)
{
    return await CreateUser(name, email).MapAsync(async user =>
    {
        await _dbContext.AddAsync(user);
        return user;
    });
}

[HttpGet("/users/create")]
public async Task<IActionResult> CreateUser(CreateUserRequest req)
{
    Result<User> userResult = await _repo.AddUserAsync(req.Name, req.Email);

    return userResult.Match(
        user => Ok(user),
        error => MapToActionResult(error));
}

public IActionResult MapToActionResult(IError err) => err switch
{
    ValidationError vErr => BadRequest(new { Errors = vErr.ErrorInfos, Message = vErr.Message }),
    NotFoundError nErr => NotFound(new { Message = nErr.Message }),
    _ => Problem()
}

Usage

Creating Result<T>

There are implicit converters from T, Error to Result<T>

Creating Result<T> from IError

IError is an interface and C# doesn't support implicit conversion from/to interface. So you have to call a Method ToResult on IError

IError err = ...;
Result<T> result = Result.FromErr<T>(err);
// or
Result<T> result = err.ToResult<T>();

Checking if the Result<T> is an error

if (result.IsError)
{
    // result is an error
}

Checking for specific Error

if (result.Error is ArgumentError err)
{
    // result is an error
}

Accessing the Result<T> result

Accessing the Value

Result<int> result = Result.From(5);

var value = result.Value;

Accessing the Error

Result<int> result = new NotFoundError(...);

IError? value = result.Error;

Performing actions based on the Result<T> result

Match

string foo = result.Match(
    value => value,
    error => $"err: {error.Message}");

Switch

Actions that don't return a value on the value or list of errors

result.Switch(
    value => Console.WriteLine(value),
    error => Console.WriteLine($"err: {error.Message}"));

Map

Map method takes a delegate which will transform success result to Result<TMap>. The delegate will only be called if Result<T> contains a success result. If Result<T> is contains a failure result then a Result<TMap> will be constructed with the errors inside Result<T>

Result<string> userNameResult = userResult.Map(user => user.Username);

You can even return Result in Map method

Result<string> userNameResult = userResult.Map(user => 
{
    if(user.HasName)
    {
        return Result.From(user.Username);
    }
    return Result.FromErr<T>(new Error("user doesn't have username"));
});

Result without a type

Result DeleteUser(Guid id)
{
    var user = await _userRepository.GetByIdAsync(id);
    if (user is null)
    {
        return new NotFoundError("User not found");
    }

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

Error Types

Built-in Error Types

• Error
• OperationCancelledError
• AggregateError
• ArgumentError
• FormatError
• ExceptionError

Custom error

You can create your own error type. You can either implement the IError interface or inherit the Error record.

Benefit of implementing IError interface

You get more control on your type. But you can't implicitly convert it to Result<T>

Benefit of inheriting Error record

Can be converted Implicitly to Result<T>

Examples

FileNotFoundError notFoundErr = new("file.txt");
Result<T> result = Result.FromErr<T>(notFoundErr); // Ok
Result<T> result = notFoundErr.ToResult<T>(); // Ok
Result<T> result = notFoundErr; // Error

public class FileNotFoundError : IError
{
    public FileNotFoundError(string fileName)
    {
        FileName = fileName;
    }

    public string FileName { get; }

    public string Message => $"{FileName} was not found";
}

FileNotFoundError notFoundErr = new("file.txt");
Result<T> result = Result.FromErr<T>(notFoundErr); // Ok
Result<T> result = notFoundErr.ToResult<T>(); // Ok
Result<T> result = notFoundErr; // Ok too

public record FileNotFoundError(string FileName) : Error($"{FileName} was not found", nameof(FileNotFoundError));

Suggestions and Changes

Any suggestion on improving this project will be helpful

Credits

• ErrorOr - A simple, fluent discriminated union of an error or a result. BetterErrors package is directly inspired from ErrorOr package with the benefits of error customization