Implementation the Results Pattern for .NET API applications.
Get Started
$ dotnet add package LCSoft.ResultsReadme
LCSoft: Results Pattern for .NET
A robust, flexible, and type-safe result and error handling library for .NET applications. Provides unified success/failure result types with rich error information and functional pattern matching for clean, expressive code.
✨ Features
- Unified result types for success/failure handling
- Generic Results<TValue> and non-generic Results classes
- Simplified alternative via sResults<TValue> and sResults using the lightweight Error record
- Encapsulation of success value or error with rich error details
- Functional Match methods supporting both Func and Action delegates
- Implicit conversion operators for easy construction from values or errors
- Abstract ErrorsType base class with error code, name, and registry
- Standard predefined error types via StandardErrorType
- Detailed Error record with error code, message, and categorized error type
- ErrorType enum classifying error categories
- Interfaces IResult<TError> and IResult<TValue, TError> with default implementations
- Explicit interface implementations for polymorphic usage
- Centralized error code registry and lookup by code
- Nullable callback support in Match methods
- Designed for testability and code coverage compatibility
- Extensible architecture for custom error and result handling
- Suitable for layered and domain-driven design applications
📦 Installation
Install via NuGet:
dotnet add package LCSoft.Results
Or via Package Manager:
Install-Package LCSoft.Results
🚀 Quick Start
Basic Usage
using LCSoft.Results;
Results result = DoSomething();
if (result.IsSuccess)
{
Console.WriteLine("Success!");
}
else
{
Console.WriteLine($"Failed: {result.Error}");
}
With a Value
Results<int> result = Calculate();
if (result.IsSuccess)
{
int value = result.Value;
Console.WriteLine($"Result: {value}");
}
else
{
Console.WriteLine($"Error: {result.Error}");
}
Non-generic Result
Results result = Results.Success();
result.Match(
success: () => Console.WriteLine("Operation succeeded!"),
failure: error => Console.WriteLine($"Failed with error: {error.Name}")
);
Generic Result with Value
Results<int> result = 42; // implicit success
int value = result.Match(
onSuccess: val => val * 2,
onFailure: error => -1
);
Console.WriteLine(value); // 84
Handling Errors
var error = StandardErrorType.Validation;
Results failureResult = Results.Failure(error);
failureResult.Match(
success: () => Console.WriteLine("This won't be called."),
failure: err => Console.WriteLine($"Validation failed: {err.Name}")
);
Using sResults and sResults
For lighter scenarios, you can use sResults and sResults<T> which use a simplified Error record structure.
sResults<int> result = 10;
result.Match(
success: val => Console.WriteLine($"Success with value {val}"),
failure: err => Console.WriteLine($"Failed with code {err.Code}")
);
Extending Errors
public sealed class CustomErrorType : ErrorsType
{
public static readonly CustomErrorType CustomFailure = new(100, "CustomFailure");
private CustomErrorType(int code, string name) : base(code, name)
{
Register(this);
}
}
Use ErrorsType.FromCode(code) to retrieve error types dynamically.
Interfaces
- IResult<TError> for basic result contracts
- IResult<TValue, TError> for generic result contracts
- Both provide functional Match methods with success and failure delegates
✅ Example
Results<int> ParseNumber(string input)
{
if (int.TryParse(input, out int number))
return Results<int>.Success(number);
return Results<int>.Failure(StandardErrorType.GenericFailure);
}
📄 License
This project is licensed under the CC-BY-NC-ND-4.0 License. See the LICENSE file for details.
🙌 Contributing
Contributions are welcome! Please open issues or submit pull requests on GitHub.