C # загальне обмеження типу для всього зведеного нанівець

Отже, у мене є цей клас:

public class Foo<T> where T : ???
{
    private T item;

    public bool IsNull()
    {
        return item == null;
    }

}

Тепер я шукаю обмеження типу, яке дозволяє мені використовувати все як параметр типу, який може бути null. Це означає, що всі типи посилань, а також усі Nullable( T?) типи:

Foo<String> ... = ...
Foo<int?> ... = ...

має бути можливим.

Використання classяк обмеження типу дозволяє лише використовувати еталонні типи.

Додаткова інформація: Я пишу заявку на труби та фільтри та хочу використовувати nullпосилання як останній елемент, який переходить у трубопровід, щоб кожен фільтр міг добре вимикатися, робити очищення тощо ...

Якщо ви готові перевірити час виконання в конструкторі Foo, а не перевірку часу компіляції, ви можете перевірити, чи не тип є посилальним чи нульовим, і викинете виняток, якщо це так.

Я розумію, що лише перевірка часу виконання може бути неприйнятною, але про всяк випадок:

public class Foo<T>
{
    private T item;

    public Foo()
    {
        var type = typeof(T);

        if (Nullable.GetUnderlyingType(type) != null)
            return;

        if (type.IsClass)
            return;

        throw new InvalidOperationException("Type is not nullable or reference type.");
    }

    public bool IsNull()
    {
        return item == null;
    }
}

Потім компілюється наступний код, але останній ( foo3) кидає виняток у конструкторі:

var foo1 = new Foo<int?>();
Console.WriteLine(foo1.IsNull());

var foo2 = new Foo<string>();
Console.WriteLine(foo2.IsNull());

var foo3= new Foo<int>();  // THROWS
Console.WriteLine(foo3.IsNull());

Я не знаю, як реалізувати еквівалентні АБО в генериці. Однак я можу запропонувати використовувати ключове слово за замовчуванням , щоб створити null для змінних типів та 0 значення для структур:

public class Foo<T>
{
    private T item;

    public bool IsNullOrDefault()
    {
        return Equals(item, default(T));
    }
}

Ви також можете реалізувати версію Nullable:

class MyNullable<T> where T : struct
{
    public T Value { get; set; }

    public static implicit operator T(MyNullable<T> value)
    {
        return value != null ? value.Value : default(T);
    }

    public static implicit operator MyNullable<T>(T value)
    {
        return new MyNullable<T> { Value = value };
    }
}

class Foo<T> where T : class
{
    public T Item { get; set; }

    public bool IsNull()
    {
        return Item == null;
    }
}

Приклад:

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine(new Foo<MyNullable<int>>().IsNull()); // true
        Console.WriteLine(new Foo<MyNullable<int>> {Item = 3}.IsNull()); // false
        Console.WriteLine(new Foo<object>().IsNull()); // true
        Console.WriteLine(new Foo<object> {Item = new object()}.IsNull()); // false

        var foo5 = new Foo<MyNullable<int>>();
        int integer = foo5.Item;
        Console.WriteLine(integer); // 0

        var foo6 = new Foo<MyNullable<double>>();
        double real = foo6.Item;
        Console.WriteLine(real); // 0

        var foo7 = new Foo<MyNullable<double>>();
        foo7.Item = null;
        Console.WriteLine(foo7.Item); // 0
        Console.WriteLine(foo7.IsNull()); // true
        foo7.Item = 3.5;
        Console.WriteLine(foo7.Item); // 3.5
        Console.WriteLine(foo7.IsNull()); // false

        // var foo5 = new Foo<int>(); // Not compile
    }
}

Я зіткнувся з цим питанням для більш простого випадку, коли потрібно загальний статичний метод, який міг би прийняти що-небудь "змінне" (або типи посилань, або Nullables), що привело мене до цього питання, не маючи задовільного рішення. Тож я придумав власне рішення, яке було порівняно простіше вирішити, ніж заявлене питання ОП, просто маючи два перевантажені методи: один, який приймає Tта має обмеження, where T : classі інший, який приймає T?і має where T : struct.

Потім я зрозумів, що це рішення також може бути застосоване до цієї проблеми для створення рішення, яке можна перевірити під час компіляції, зробивши конструктор приватним (або захищеним) та використовуючи статичний заводський метод:

    //this class is to avoid having to supply generic type arguments 
    //to the static factory call (see CA1000)
    public static class Foo
    {
        public static Foo<TFoo> Create<TFoo>(TFoo value)
            where TFoo : class
        {
            return Foo<TFoo>.Create(value);
        }

        public static Foo<TFoo?> Create<TFoo>(TFoo? value)
            where TFoo : struct
        {
            return Foo<TFoo?>.Create(value);
        }
    }

    public class Foo<T>
    {
        private T item;

        private Foo(T value)
        {
            item = value;
        }

        public bool IsNull()
        {
            return item == null;
        }

        internal static Foo<TFoo> Create<TFoo>(TFoo value)
            where TFoo : class
        {
            return new Foo<TFoo>(value);
        }

        internal static Foo<TFoo?> Create<TFoo>(TFoo? value)
            where TFoo : struct
        {
            return new Foo<TFoo?>(value);
        }
    }

Тепер ми можемо використовувати його так:

        var foo1 = new Foo<int>(1); //does not compile
        var foo2 = Foo.Create(2); //does not compile
        var foo3 = Foo.Create(""); //compiles
        var foo4 = Foo.Create(new object()); //compiles
        var foo5 = Foo.Create((int?)5); //compiles

Якщо ви хочете конструктор без параметрів, ви не отримаєте тонкості перевантаження, але все одно можете зробити щось подібне:

    public static class Foo
    {
        public static Foo<TFoo> Create<TFoo>()
            where TFoo : class
        {
            return Foo<TFoo>.Create<TFoo>();
        }

        public static Foo<TFoo?> CreateNullable<TFoo>()
            where TFoo : struct
        {
            return Foo<TFoo?>.CreateNullable<TFoo>();
        }
    }

    public class Foo<T>
    {
        private T item;

        private Foo()
        {
        }

        public bool IsNull()
        {
            return item == null;
        }

        internal static Foo<TFoo> Create<TFoo>()
            where TFoo : class
        {
            return new Foo<TFoo>();
        }

        internal static Foo<TFoo?> CreateNullable<TFoo>()
            where TFoo : struct
        {
            return new Foo<TFoo?>();
        }
    }

І використовуйте його так:

        var foo1 = new Foo<int>(); //does not compile
        var foo2 = Foo.Create<int>(); //does not compile
        var foo3 = Foo.Create<string>(); //compiles
        var foo4 = Foo.Create<object>(); //compiles
        var foo5 = Foo.CreateNullable<int>(); //compiles

У цього рішення є недоліки, один полягає в тому, що ви можете віддати перевагу використанню "нового" для побудови об'єктів. Іншим є те , що ви не будете в змозі використати в Foo<T>якості загального аргументу типу для типу обмеження що - щось на кшталт: where TFoo: new(). Нарешті, тут вам потрібен додатковий код, який особливо збільшиться, якщо вам потрібно кілька перевантажених конструкторів.

Як вже було сказано, ви не можете перевірити час компіляції. Загальних обмежень у .NET вкрай не вистачає, і вони не підтримують більшість сценаріїв.

Однак я вважаю це кращим рішенням для перевірки часу виконання. Його можна оптимізувати під час компіляції JIT, оскільки вони обидві константи.

public class SomeClass<T>
{
    public SomeClass()
    {
        // JIT-compile time check, so it doesn't even have to evaluate.
        if (default(T) != null)
            throw new InvalidOperationException("SomeClass<T> requires T to be a nullable type.");

        T variable;
        // This still won't compile
        // variable = null;
        // but because you know it's a nullable type, this works just fine
        variable = default(T);
    }
}

Таке обмеження типу неможливо. Згідно з документацією про типові обмеження, не існує обмеження, яке фіксує як нульовий, так і опорний типи. Оскільки обмеження можна поєднувати лише сполучником, немає можливості створити таке обмеження комбінацією.

Тим не менш, ти можеш повернутись до параметра типу обмеження, оскільки ти завжди можеш перевірити наявність == null. Якщо тип є типовим типом, чек просто завжди оцінюватиметься як хибне. Тоді ви, можливо, отримаєте попередження R # "Можливе порівняння типу значення з нульовим", що не є критичним, якщо семантика підходить саме вам.

Альтернативою може бути використання

object.Equals(value, default(T))

замість нульової перевірки, оскільки за замовчуванням (T), де клас T: завжди є нульовим. Це, однак, означає, що ви не можете розрізнити погоду, а не нульове значення ніколи не було встановлено явно або було просто встановлено за замовчуванням.

я використовую

public class Foo<T> where T: struct
{
    private T? item;
}

    public class Foo<T>
    {
        private T item;

        public Foo(T item)
        {
            this.item = item;
        }

        public bool IsNull()
        {
            return object.Equals(item, null);
        }
    }

    var fooStruct = new Foo<int?>(3);
        var b = fooStruct.IsNull();

        var fooStruct1 = new Foo<int>(3);
        b = fooStruct1.IsNull();

        var fooStruct2 = new Foo<int?>(null);
        b = fooStruct2.IsNull();

        var fooStruct3 = new Foo<string>("qqq");
        b = fooStruct3.IsNull();

        var fooStruct4 = new Foo<string>(null);
        b = fooStruct4.IsNull();