Ограничение общего на вещи, которые могут быть нулевыми

Ответ 1

Нет, нет способа сделать это во время компиляции.

Лично я просто хотел бы T быть любым, тогда я бы проверял его достоверность в статическом конструкторе:

public class MyGeneric<T>
{
    static MyGeneric()
    {
        var def = default(T); 
        if (def is ValueType && Nullable.GetUnderlyingType(typeof(T)) == null)
        {
            throw new InvalidOperationException(
                string.Format("Cannot instantiate with non-nullable type: {0}",
                    typeof(T)));
        }
    }
}

Ответ 2

Нет, вы не можете ограничить общий доступ только тем, что может быть нулевым. См. Как я могу вернуть NULL из общего метода в С#?. Единственными представленными решениями были либо использование default(T), либо использование ограничения class, потому что нет возможности ограничить только типы с возможностью NULL.

Не понятно, какова ваша цель. Изменение только пары строк вашего примера кода делает работу с любым типом, а не только с нулевыми значениями, поэтому я не понимаю, почему вы пытаетесь его ограничить.

В этом примере также будут работать с MyGeneric<int?> или MyGeneric<int>:

using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

namespace Test
{
    public class MyGeneric<T> // removed "where T : class"
    {
        public void Print(params T[] vals)
        {
            Print((IEnumerable<T>) vals);
        }

        public void Print(IEnumerable<T> vals)
        {
            foreach (var v in vals.OfType<T>()) // use "OfType" instead of "Where"
            {
                Trace.WriteLine(v.ToString());
            }
            Trace.WriteLine(string.Empty);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            MyGeneric<string> foo = new MyGeneric<string>();
            foo.Print("a", "b", "c", null, null, "g");
        }
    }
}

Ответ 3

Единственное, что непонятно из вашего примера, - это то, почему вы хотите сделать это с помощью родового уровня класса, а не общего уровня метода. На основе вашего примера вы можете сделать следующее:

public class NonGenericClass
{
    public void Print<T>(IEnumerable<T?> vals) where T : struct
    {
        PrintRestricted(vals.Where(v =>  v.HasValue));
    }

    public void Print<U>(IEnumerable<T> vals) where T : class
    {
        PrintRestricted(vals.Where(v => v != default(T)));
    }

    private void PrintRestricted<U>(IEnumerable<T> vals)
    {
        foreach (var v in vals)
        {
            Trace.WriteLine(v.ToString());
        }
        Trace.WriteLine(string.Empty);
    }
}

За счет написания метода упаковки, который делает ограничение, вы можете получить ту же функциональность.

Ответ 4

Иногда система типа просто не может делать то, что вы хотите. В этих случаях вы либо меняете то, что хотите, либо работаете вокруг.

Рассмотрим пример класса Tuple<>. "Самый большой" вариант выглядит как Tuple<T1, T2, T3, T4, T5, T6, T7, TRest>, где TRest должен быть Tuple<>. Это не ограничение времени компиляции, это строго проверка времени выполнения. Возможно, вам придётся прибегнуть к чему-то подобному, если вы хотите применить требование nullability для T в Foo<T>, поддерживая как типичные классы, так и nullable structs.

/// <summary>
/// Class Foo requires T to be type that can be null. E.g., a class or a Nullable&lt;T&gt;
/// </summary>
/// <typeparam name="T"></typeparam>
class Foo<T>
{
    public Foo()
    {
        if (default(T) != null)
            throw new InvalidOperationException(string.Format("Type {0} is not valid", typeof(T)));
    }

    // other members here
}

При этом я документирую, что класс будет требовать, чтобы T была совместима с типами NULL и выбрала конструктор, если это не так.

Foo<string> foo = new Foo<string>(); // OK
Foo<int?> works = new Foo<int?>(); // also OK
Foo<int> broken = new Foo<int>(); // not OK