关于LanguageExt.Core Result<T>使用困惑：求示例或更优Result模式包推荐

一、优化LanguageExt.Result的使用体验 #

如果你觉得LanguageExt的Result灵活性不足，可以通过模式匹配或扩展方法解决守卫和异常获取的问题：

1. 用模式匹配实现便捷守卫 #

LanguageExt的Result本质是 discriminated union，可直接用C#模式匹配做条件守卫：

using LanguageExt;
using static LanguageExt.Prelude;

// 定义返回带异常的Result方法
public Result<int, Exception> Divide(int numerator, int denominator)
{
    try
    {
        return Success(numerator / denominator);
    }
    catch (Exception ex)
    {
        return Failure<int, Exception>(ex);
    }
}

// 模式匹配做守卫
var divisionResult = Divide(10, 0);

if (divisionResult is Success<int, Exception> success)
{
    Console.WriteLine($"计算结果：{success.Value}");
}
else if (divisionResult is Failure<int, Exception> failure)
{
    // 直接获取异常信息
    Console.WriteLine($"错误：{failure.Error.Message}");
    Console.WriteLine($"异常堆栈：{failure.Error.StackTrace}");
}

2. 扩展方法简化守卫与异常获取 #

如果频繁使用，可以封装扩展方法减少重复代码：

public static class ResultExtensions
{
    // 判断是否成功
    public static bool IsSuccess<T, TErr>(this Result<T, TErr> result) 
        => result.IsSuccess;

    // 判断是否失败
    public static bool IsFailure<T, TErr>(this Result<T, TErr> result) 
        => result.IsFailure;

    // 获取失败时的错误/异常
    public static TErr? GetError<T, TErr>(this Result<T, TErr> result) 
        => result.IsFailure ? ((Failure<T, TErr>)result).Error : default;
}

// 使用扩展方法
var result = Divide(10, 2);
if (result.IsSuccess())
{
    // 处理成功逻辑
}
else
{
    var ex = result.GetError<int, Exception>();
    if (ex != null)
    {
        Console.WriteLine($"捕获异常：{ex.Message}");
    }
}

二、推荐更灵活的Result模式替代包 #

如果LanguageExt的Result仍无法满足需求，以下两个包更适合日常场景：

1. ErrorOr #

轻量级、零依赖，原生支持C#模式匹配，可直接作为返回值，内置错误分类，方便携带异常信息：

using ErrorOr;

public ErrorOr<int> Divide(int numerator, int denominator)
{
    if (denominator == 0)
        return Error.Validation("Denominator cannot be zero");
    
    try
    {
        return numerator / denominator;
    }
    catch (Exception ex)
    {
        // 将异常附加到错误元数据中
        return Error.Failure(ex.Message).WithMetadata("Exception", ex);
    }
}

// 使用示例
var result = Divide(10, 0);
if (result.IsError)
{
    var error = result.FirstError;
    // 提取异常信息
    if (error.Metadata.TryGetValue("Exception", out var exObj) && exObj is Exception ex)
    {
        Console.WriteLine($"异常详情：{ex.Message}");
    }
}
else
{
    Console.WriteLine($"结果：{result.Value}");
}

2. OneOf #

基于 discriminated union 的强类型解决方案，支持多个成功/失败类型，灵活性极高，适合复杂业务场景：

using OneOf;

// 定义成功和失败类型
public record DivideSuccess(int Value);
public record DivideError(Exception Exception);

// 返回OneOf类型
public OneOf<DivideSuccess, DivideError> Divide(int numerator, int denominator)
{
    try
    {
        return new DivideSuccess(numerator / denominator);
    }
    catch (Exception ex)
    {
        return new DivideError(ex);
    }
}

// 使用模式匹配守卫
var result = Divide(10, 0);
if (result.TryPickT0(out var success, out var error))
{
    Console.WriteLine($"结果：{success.Value}");
}
else
{
    Console.WriteLine($"异常：{error.Exception.Message}");
}

// 或用Switch处理分支
result.Switch(
    success => Console.WriteLine($"成功：{success.Value}"),
    error => Console.WriteLine($"失败：{error.Exception.Message}")
);

内容的提问来源于stack exchange，提问作者Ove Stoerholt