In project development, the result returned by a method (success or failure) is important to our development. Traditional methods, such as indicating an error through an exception or using a specific return type (e.g., Boolean plus an output parameter), are effective but may lack intuition and flexibility.
The FluentResults library was created to greatly optimize this process in a way that is both fluid and expressive. By using FluentResults, the results of operations, including success status, error messages, warnings, and additional information, can be conveyed in a more natural and understandable way, improving the readability and maintainability of your code.
This approach not only makes error handling more centralized and consistent, it also makes the code structure clearer and the logic more fluid.
Projects
FluentResults is a widely used library in .NET environments that provides an elegant way to handle the results and errors of method execution.
utilizationFluentResults, it is easy to create objects that contain success values, errors, warnings, or messages, and to manipulate these objects through chained calls.
So how do you useFluentResults to gracefully handle results and error messages?
Using FluentResults
1. Install FluentResults
First, install theFluentResultsIn Visual Studio, the NuGet package manager can be installed. The following command can also be entered in Visual Studio through the NuGet Package Manager console:
Install-Package FluentResults
Alternatively, add a reference to the NuGet package in your project file.
2、Create Result object
utilizationResult class's static methods to create the resultant object.Result class provides several methods to create different types of results, such as success, failure, success with a warning or message, etc.
using FluentResults; static void Main(string[] args) { var result = IsInteger(""); if () { ($"Result: {}"); } else { ($"Result: {[0].Message}|{[0]."); } } public static Result<int> IsInteger(string input) { // Assuming the input is empty or null, we can choose to assume it is not a number if (string.IsNullOrWhiteSpace(input)) { return <int>("Input is empty or null, can't tell if it's a number or not"); } // Use try to convert the input to an integer // If the conversion is successful, the out parameter will contain the converted value and the method will return true. // If the conversion fails, the method returns false if (int.TryParse(input, out int result)) { return (result); } // If it cannot be converted to an integer, the input is considered not to be a number return <int>("Input is not a number"); }
running result
By using the Result class we can see that the method run returns the standard interface parameters, including IsSuccess, Message, Errors and other parameters, helping us to quickly implement the return structure.
3. Chaining results
FluentResults Allows you to chain calls to process results, which makes error handling and logical flow clearer and more intuitive.
It's important to note that FluentResults themselves have aResult The type does not directly provideOnSuccess cap (a poem)OnFailure Such chained methods, as they may have been added as extension methods in some version of FluentResults, or defined in a custom extension based on FluentResults.
Custom Extension Classes
/// <summary> /// Result Extended Methods /// </summary> public static class ResultExtensions { /// <summary> /// success callback /// </summary> /// <param name="result"></param> /// <param name="successAction"></param> /// <returns></returns> public static Result OnSuccess(this Result result, Action successAction) { if () { successAction?.Invoke(); } return result; // Return results to support chained calls } /// <summary> /// failed pullback /// </summary> /// <param name="result"></param> /// <param name="failureAction"></param> /// <returns></returns> public static Result OnFailure(this Result result, Action<IError> failureAction) { if (! && != null) { foreach (var error in ) { failureAction?.Invoke(error); } } return result; // Return results to support chained calls } }
Custom Methods
/// <summary> /// Verify that the input string is an integer /// </summary> /// <param name="input"></param> /// <returns></returns> public static Result IsIntegerInfo(string input) { // Assuming the input is empty or null, we can choose to assume it is not a number if (string.IsNullOrWhiteSpace(input)) { return ("Input is empty or null, can't tell if it's a number or not"); } // Use try to convert the input to an integer // If the conversion is successful, the out parameter will contain the converted value and the method will return true. // If the conversion fails, the method returns false if (int.TryParse(input, out int result)) { return (); } // If it cannot be converted to an integer, the input is considered not to be a number return ("Input is not a number"); }
Recall Example
var result = IsIntegerInfo("") .OnSuccess(() => { // Successful processing ("Success!"); }) .OnFailure(error => { // Processing failures ("Failed: " + ); }); // Note: It may not be safe to use the result variable in OnSuccess or OnFailure. // Because these callbacks may have been modified before these callbacks were executed. // A better approach is to use local variables in OnSuccess/OnFailure lambda expressions.
running result
Two extension methods are defined in this exampleOnSuccess cap (a poem)OnFailure, which accept callback functions to be executed on success and failure, respectively. These methods first check theResult state of the object, and then call the appropriate callback function based on the state. Finally, they return the originalResult object to support chained calls.
Please note that the examples are simplified for illustrative purposes and may not include all features and optimizations actually available in the FluentResults library. In practice, the documentation and source code of FluentResults should be reviewed to understand the specific features provided.
4、FluentResults Advanced Features
FluentResults provides many advanced features such as chained calls, custom error types, and error objects containing additional data and metadata.
For example, you can use theto include more contextual information.
return ("Input error.").WithError("The input value must be greater than zero.");
5、Customize Result type
FluentResults Inheritance is also supported through theResult class to create customized result types to carry additional data or state in the result.
public class CommonResult { public Result Result { get; } public string MyData { get; } public CommonResult(Result result, string myData) { Result = result; MyData = myData; ($"{nameof(CommonResult)}: {MyData}|{result}"); } }
Recall Example
public static CommonResult DemoResult(string input) { bool isSuccess =false; string errorMessage = "The input string is not a number"; string myData = "Test it."; Result result = isSuccess ? () : (errorMessage); return new CommonResult(result, myData); }
running result
With the above steps, you can quickly and easily use theFluentResults to handle results and errors. This improves the readability and maintainability of the code, and also makes error handling more centralized and uniformly standardized.
Usage Scenarios
- API Development: FluentResults builds clear, consistent and easy to understand error responses when processing HTTP requests and responses.
- Business Logic Validation: When performing business logic validation, FluentResults can validate multiple errors and return them at once.
summarize
FluentResults provides a rich API that can be used flexibly to integrate with existing .NET codebases and frameworks such as Core, Entity Framework, etc., as well as with other third-party libraries to provide more comprehensive error handling and results functionality.
If you need a better way to handle results in your projects and want to improve the readability and maintainability of your code, then FluentResults is a good choice.
open source address
If you find this article useful, welcome to join WeChat [DotNet technician] community to share ideas and grow with other tech-loving peers.
