C#.Net 中的可选返回

Question

Java 1.8 正在接收Optional<T>类，它允许我们明确说明方法何时可以返回空值并“强制”其使用者在使用它之前验证它是否不为空（ isPresent() ）。

我看到 C# 有Nullable<T> ，它做了类似的事情，但具有基本类型。 它似乎用于数据库查询，以区分值何时存在且为 0，何时不存在且为空。

但似乎 C# 的Nullable<T>不适用于对象，仅适用于基本类型，而 Java 的Optional<T>仅适用于对象，不适用于基本类型。

C# 中是否有 Nullable/Optional 类，它迫使我们在提取和使用对象之前测试对象是否存在？

Answer 1

不是在语言中，不，但您可以自己制作：

public struct Optional<T>
{
    public bool HasValue { get; private set; }
    private T value;
    public T Value
    {
        get
        {
            if (HasValue)
                return value;
            else
                throw new InvalidOperationException();
        }
    }

    public Optional(T value)
    {
        this.value = value;
        HasValue = true;
    }

    public static explicit operator T(Optional<T> optional)
    {
        return optional.Value;
    }
    public static implicit operator Optional<T>(T value)
    {
        return new Optional<T>(value);
    }

    public override bool Equals(object obj)
    {
        if (obj is Optional<T>)
            return this.Equals((Optional<T>)obj);
        else
            return false;
    }
    public bool Equals(Optional<T> other)
    {
        if (HasValue && other.HasValue)
            return object.Equals(value, other.value);
        else
            return HasValue == other.HasValue;
    }
}

请注意，您将无法模拟Nullable<T>某些行为，例如将没有值的可空值装箱为空的能力，而不是装箱的可空值，因为它对此具有特殊的编译器支持（以及其他一些）行为。

Answer 2

在我看来，任何公开HasValue属性的Option实现都是对整个想法的失败。 可选对象的要点是您可以无条件调用它们的内容，而无需测试内容是否存在。

如果您必须测试可选对象是否包含值，那么与常见的null测试相比，您没有做任何新的事情。

这是我详细解释可选对象的文章： C# 中选项/可能类型的自定义实现

这是包含代码和示例的 GitHub 存储库： https : //github.com/zoran-horvat/option

如果您不愿意使用重量级的 Option 解决方案，那么您可以轻松构建一个轻量级的解决方案。 您可以创建自己的Option<T>类型来实现IEnumerable<T>接口，以便您可以利用 LINQ 扩展方法将调用变为可选。 这是最简单的可能实现：

public class Option<T> : IEnumerable<T>
{
    private readonly T[] data;

    private Option(T[] data)
    {
        this.data = data;
    }

    public static Option<T> Create(T value)
    {
        return new Option<T>(new T[] { value });
    }

    public static Option<T> CreateEmpty()
    {
        return new Option<T>(new T[0]);
    }

    public IEnumerator<T> GetEnumerator()
    {
        return ((IEnumerable<T>)this.data).GetEnumerator();
    }

    System.Collections.IEnumerator
        System.Collections.IEnumerable.GetEnumerator()
    {
        return this.data.GetEnumerator();
    }
}

使用这个Option<T>类型是通过 LINQ 完成的：

Option<Car> optional = Option<Car>.Create(myCar);
string color = optional
  .Select(car => car.Color.Name)
  .DefaultIfEmpty("<no car>")
  .Single();  // you can call First(), too

您可以在以下文章中找到有关可选对象的更多信息：

• C#中Option/Maybe类型的自定义实现
• 了解选项（也许）功能类型
• 如何降低圈复杂度：选项函数类型

您可以参考我的视频课程，了解有关如何使用Option类型和其他方式简化控制流的更多详细信息： 使您的 C# 代码在 .NET 中更具功能性和战术性设计模式：控制流

第一个视频课程（ 使您的 C# 代码更具功能性）详细介绍了面向铁路的编程，包括Either和Option类型以及如何使用它们来管理可选对象以及处理异常情况和错误。

Answer 3

C# 中有更好的选项类型实现。 您可以在Zoran Horvat 的.NET中的Tactical design patterns in .NET 中找到此实现，网址为 Multiplesight.com。 它包括解释为什么以及如何使用它。 基本思想是将选项类实现为 IEnumerable<> 接口的实现。

public class Option<T> : IEnumerable<T>
{
    private readonly T[] data;

    private Option(T[] data)
    {
        this.data = data;
    }

    public static Option<T> Create(T element)
    {
        return new Option<T>(new[] { element });
    }

    public static Option<T> CreateEmpty()
    {
        return new Option<T>(new T[0]);
    }

    public IEnumerator<T> GetEnumerator()
    {
        return ((IEnumerable<T>) this.data).GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
}

Answer 4

没有内置的东西，但你可以定义你自己的。 请注意，如果不定义映射/绑定运算符，则Option<T>实现没有意义。

public struct Option<T>
{
    private bool hasValue;
    private T value;

    public Option(T value)
    {
        if (value == null) throw new ArgumentNullException("value");
        this.hasValue = true;
        this.value = value;
    }

    public Option<TOut> Select<TOut>(Func<T, TOut> selector)
    {
        return this.hasValue ? new Option<TOut>(selector(this.value)) : new Option<TOut>();
    }

    public Option<TOut> SelectMany<TOut>(Func<T, Option<TOut>> bind)
    {
        return this.hasValue ? bind(this.value) : new Option<TOut>();
    }

    public bool HasValue
    {
        get { return this.hasValue; }
    }

    public T GetOr(T @default)
    {
        return this.hasValue ? this.value : @default;
    }
}

Answer 5

在“C# 函数式语言扩展”项目https://github.com/louthy/language-ext 中存在 F# 的 Option 对象以及其他函数式模式

Answer 6

您可以使用FSharpCore.dll程序FSharpCore.dll Microsoft.FSharp.Core.FSharpOption<T> ，而不是编写自己的类。 不幸的是，F# 类型在 C# 中使用时有点笨拙。

//Create
var none = FSharpOption<string>.None;
var some1 = FSharpOption<string>.Some("some1");
var some2 = new FSharpOption<string>("some2");

//Does it have value?
var isNone1 = FSharpOption<string>.get_IsNone(none);
var isNone2 = OptionModule.IsNone(none);
var isNone3 = FSharpOption<string>.GetTag(none) == FSharpOption<string>.Tags.None;

var isSome1 = FSharpOption<string>.get_IsSome(some1);
var isSome2 = OptionModule.IsSome(some1);
var isSome3 = FSharpOption<string>.GetTag(some2) == FSharpOption<string>.Tags.Some;

//Access value
var value1 = some1.Value; //NullReferenceException when None
var value2 = OptionModule.GetValue(some1); //ArgumentException when None

Answer 7

也许这更接近于 F# Option 类型

public struct Option<T>
{
    private T value;
    private readonly bool hasValue;

    public bool IsSome => hasValue;

    public bool IsNone => !hasValue;

    public T Value
    {
        get
        {
            if (!hasValue) throw new NullReferenceException();
            return value;
        }
    }

    public static Option<T> None => new Option<T>();

    public static Option<T> Some(T value) => new Option<T>(value);

    private Option(T value)
    {
        this.value = value;
        hasValue = true;
    }

    public TResult Match<TResult>(Func<T, TResult> someFunc, Func<TResult> noneFunc) =>
        hasValue ? someFunc(value) : noneFunc();

    public override bool Equals(object obj)
    {
        if (obj is Option<T>)
        {
            var opt = (Option<T>)obj;
            return hasValue ? opt.IsSome && opt.Value.Equals(value) : opt.IsNone;
        }
        return false;
    }

    public override int GetHashCode() =>
        hasValue ? value.GetHashCode() : 0;
}

Answer 8

前段时间我决定使用最新的 C# 版本之一来实现某种 Optional<> Java 类原型。

这里是：

public sealed class Optional<T>
{
    private static readonly Optional<T> EMPTY = new Optional<T>();
    private readonly T value;

    private Optional() => value = default;
    private Optional(T arg) => value = arg.RequireNonNull("Value should be presented");

    public static Optional<T> Empty() => EMPTY;
    public static Optional<T> Of(T arg) => new Optional<T>(arg);
    public static Optional<T> OfNullable(T arg) => arg != null ? Of(arg) : Empty();
    public static Optional<T> OfNullable(Func<T> outputArg) => outputArg != null ? Of(outputArg()) : Empty();

    public bool HasValue => value != null;

    public void ForValuePresented(Action<T> action) => action.RequireNonNull()(value);

    public IOption<T> Where(Predicate<T> predicate) => HasValue 
        ? predicate.RequireNonNull()(value) ? this : Empty() : this;

    public IOption<TOut> Select<TOut>(Func<T, TOut> select) => HasValue 
        ? Optional<TOut>.OfNullable(select.RequireNonNull()(value)) 
        : Optional<TOut>.Empty();

    public IOption<IOption<TOut>> SelectMany<TOut>(Func<T, IOption<TOut>> select) => HasValue 
        ? Optional<IOption<TOut>>.OfNullable(select.RequireNonNull()(value)) 
        : Optional<IOption<TOut>>.Empty();

    public T Get() => value;
    public T GetCustomized(Func<T, T> getCustomized) => getCustomized.RequireNonNull()(value);
    public U GetCustomized<U>(Func<T, U> getCustomized) => getCustomized.RequireNonNull()(value);

    public T OrElse(T other) => HasValue ? value : other;
    public T OrElseGet(Func<T> getOther) => HasValue ? value : getOther();
    public T OrElseThrow<E>(Func<E> exceptionSupplier) where E : Exception => HasValue ? value : throw exceptionSupplier();

    public static explicit operator T(Optional<T> optional) => OfNullable((T) optional).Get();
    public static implicit operator Optional<T>(T optional) => OfNullable(optional);

    public override bool Equals(object obj)
    {
        if (obj is Optional<T>) return true;
        if (!(obj is Optional<T>)) return false;
        return Equals(value, (obj as Optional<T>).value);
    }

    public override int GetHashCode() => base.GetHashCode();
    public override string ToString() => HasValue ? $"Optional has <{value}>" : $"Optional has no any value: <{value}>";
}

Answer 9

C# 中是否有 Nullable/Optional 类，它迫使我们在提取和使用对象之前测试对象是否存在？

创建 Nullables 以便原始类型可以为 null。 它们的默认值不必是实际值（像 int 一样，如果没有可空值，它的默认值为 0，那么 0 是指 0 还是未设置为 0？）

不，您无法强制程序员检查对象是否为空。 不过这很好。 这样做会产生大量的开销。 如果这是一项语言功能，您多久会强制检查一次？ 首次分配变量时是否需要它？ 如果变量稍后指向另一个对象怎么办？ 你会强制它在每个方法和属性之前检查，如果失败你会抛出异常吗？ 你现在得到一个空引用异常。 强迫某人做超出你已有的事情，你不会得到什么好处。

Answer 10

从 Zoran Horvat 的回答中学到了很多。 这是我的代码。 可选可以有一个真实的值或一个空的。 在消费方面，相同的代码处理它们。

void Main()
{
    var myCar = new Car{ Color =  Color.Black, Make="Toyota"};

    Option<Car> optional = Option<Car>.Create(myCar);

    // optional is an Empty 50% of the time.
    if(new Random().NextDouble() > 0.5)
        optional = Option<Car>.CreateEmpty();



    string color = optional
    .Select(car => car.Color.Name)
    .DefaultIfEmpty("<no car>")
    .Single();
    Console.Write(color);
}

class Car {
    public Color Color { get; set; }
    public string Make { get; set;}
}

public class Option<T> : IEnumerable<T>
{
    private readonly T[] data;

    private Option(T[] data)
    {
        this.data = data;
    }

    public static Option<T> Create(T value)
    {
        return new Option<T>(new T[] { value });
    }

    public static Option<T> CreateEmpty()
    {
        return new Option<T>(new T[0]);
    }

    public IEnumerator<T> GetEnumerator()
    {
        return ((IEnumerable<T>)this.data).GetEnumerator();
    }

    System.Collections.IEnumerator
        System.Collections.IEnumerable.GetEnumerator()
    {
        return this.data.GetEnumerator();
    }
}

Answer 11

使用T? 可为空引用而不是Option<T>

从 C#8 开始，您应该弃用自定义Option<T>实现。 零困境现已完全解决。

T? 是对Option<T>的完全替代

C# 具有以下处理 null 的特性：

1. 空合并运算符
2. 空条件运算符
3. 不可为空和可为空的引用类型 (C#8 起)
4. 可配置的编译错误/警告

请记住

Option<Car> optional = Option<Car>.Create(myCar);
string color = optional
  .Select(car => car.Color.Name)
  .DefaultIfEmpty("<no car>")
  .Single();  // you can call First(), too

是相同的

string color = myCar?.Color.Name ?? "<no car>";

此外，字符串颜色也是一个不能为空的引用。

Answer 12

如果您不喜欢烘焙自己的解决方案，我会使用Language Ext 。 它在 nuget 上可用。 我最近开始使用这个库，空引用的安全性是惊人的！ 我不是这个库的专家，但它可以满足您的要求，等等。

以下是可以做的事情：

using System;
using LanguageExt;
using static LanguageExt.Prelude;

public class Demo
{
    public static Option<int> ToEvenOrNone(int i) =>
        i % 2 == 0
            ? i.Apply(Optional)
            : None;

    public static void PrintToDebug(Option<int> value) => 
        value
            .Some(Console.WriteLine)
            .None(() => Console.WriteLine("Value is not Even!"));

    public static void Test()
    {
        for (int i = 0; i < 10; i++)
        {
            PrintToDebug(ToEvenOrNone(i));
        }
    }
}

这是输出：

0
Value is not Even!
2
Value is not Even!
4
Value is not Even!
6
Value is not Even!
8
Value is not Even!

Answer 13

https://github.com/mcintyre321/OneOf

我认为这个 oneOf 类很好地重新创建了选项类型。 它甚至包括一个 .switch/.match 与模式匹配，最重要的是它在运行时工作，这是你对 Option 模式的期望。