空泛型类型 c#

Question

public class Node<E> : IPosition<E>
{
    private E element;
    public Node<E> PrevNode { get; set; }
    public Node<E> NextNode { get; set; }

    //Constructor
    public Node(E e, Node<E> p, Node<E> n)
    {
        element = e;
        PrevNode = p;
        NextNode = n;
    }
}

当我创建一个新的节点对象时，我有我想要的上述Node类，以便能够做到这一点：

Node<E> n = new Node<E>(null, null, null);

这不起作用，因为在 C# 中所有类型都不能为 null。 令我惊讶的是，当我在 Java 中尝试类似的事情时，它起作用了！ 我在 Stack Overflow 上看到了一些相关的问题，但他们没有给出我想要的结果。 我不想使用default(E) 。

Answer 1

您需要一个泛型类型约束，声明E必须是引用类型：

public class Node<E> : IPosition<E> where E : class

也就是说，除非出于其他原因还需要E成为值类型。 如果是这种情况，您需要牺牲一个或另一个要求。

可空值类型是一种选择：对于您的原始版本，缺少类型约束（因为Nullable<T>本身就是值类型），您可以使用int? . 以下代码在没有约束的情况下为我编译：

var y = new Node<int?>(null, null, null);

int? 不是int ，但也不完全不是int ，是吗？

Answer 2

令我惊讶的是，当我在 Java 中尝试类似的东西时，它确实有效。

这是因为 Java 泛型类型是通过类型擦除实现的，这实际上意味着它们都是java.lang.Object后代。

例如，您不能在 Java 中使用原始int作为Node的类型参数：您被迫使用java.lang.Integer代替。 因此，无论T是什么， element都可以被赋值为null 。

在 C# 中，类型参数没有这样的限制：编写Node<int>是完全合法的。 但是，对于int类型的element ，您不能再编写element = null ，这是您看到的错误的根本原因。

除了您提到的default(T)方法之外，您还可以要求T是引用类型，如下所示：

public class Node<E> : IPosition<E> where E : class {
    ...
}

现在将null传递给Node构造函数的初始参数是合法的，但是使用任何值类型实例化Node<T>是非法的，包括Nullable<Tx> 。

Answer 3

如果我们这样做怎么办：

首先创建一个简单的界面

public interface IOptional<T>: IEnumerable<T> {}

并编写它的实现

public class Maybe<T>: IOptional<T>
{
    private readonly IEnumerable<T> _element;
    public Maybe(T element)
        : this(new T[1] { element })
    {}
    public Maybe()
        : this(new T[0])
    {}
    private Maybe(T[] element)
    {
        _element = element;
    }
    public IEnumerator<T> GetEnumerator()
    {
        return _element.GetEnumerator();
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

在此之后，我们对您的 Node 类进行了一些更改

public class Node<E> : IPosition<E>
{
    private IOptional<E> element;
    public Node<E> PrevNode { get; set; }
    public Node<E> NextNode { get; set; }

    //Constructor
    public Node(IOptional<E> e, Node<E> p, Node<E> n)
    {
        element = e;
        PrevNode = p;
        NextNode = n;
    }
}

并使用它

Node<E> n = new Node<E>(
                new Maybe<E>(), 
                null, 
                null
             );

此字段上的 Node 类中不再有空检查

而不是这个

if (this.element != null) { .. }

像这样写

this.element.Select(e => { doSomething(e); return true; })

像这样

if (this.element.Any()) 
{ 
    var elem = this.element.First();
    // do something
}

或者写一个小的扩展方法

public static IOptional<TOutput> Match<TInput, TOutput>(
    this IEnumerable<TInput> maybe,
    Func<TInput, TOutput> some, Func<TOutput> nothing)
{
    if (maybe.Any())
    {
        return new Maybe<TOutput>(
                    some(
                        maybe.First()
                    )
                );
    }
    else
    {
        return new Maybe<TOutput>(
                    nothing()
                );
    }
}

并且这样做

var result = this.element
                 .Match(
                     some: e => e.ToString(),
                     nothing: () => "Ups"
                 )
                 .First();