C # tipe generik batasan untuk semua nullable

Jadi saya punya kelas ini:

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

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

}

Sekarang saya mencari batasan tipe yang memungkinkan saya untuk menggunakan semuanya sebagai parameter tipe yang bisa null. Itu berarti semua jenis referensi, serta semua jenis Nullable( T?):

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

harus memungkinkan.

Menggunakan classsebagai batasan tipe hanya memungkinkan saya untuk menggunakan tipe referensi.

Informasi Tambahan: Saya sedang menulis aplikasi pipa dan filter, dan ingin menggunakan nullreferensi sebagai item terakhir yang lolos ke pipa, sehingga setiap filter dapat ditutup dengan baik, melakukan pembersihan, dll ...

Jika Anda ingin melakukan pemeriksaan waktu proses di konstruktor Foo daripada melakukan pemeriksaan waktu kompilasi, Anda dapat memeriksa apakah jenisnya bukan referensi atau jenis nullable, dan memberikan pengecualian jika demikian.

Saya menyadari bahwa hanya melakukan pemeriksaan waktu proses mungkin tidak dapat diterima, tetapi untuk berjaga-jaga:

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;
    }
}

Kemudian kode berikut dikompilasi, tetapi yang terakhir ( foo3) melontarkan pengecualian dalam konstruktor:

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());

Saya tidak tahu bagaimana menerapkan setara dengan OR di obat generik. Namun saya dapat mengusulkan untuk menggunakan kata kunci default untuk membuat null untuk tipe nullable dan nilai 0 untuk struktur:

public class Foo<T>
{
    private T item;

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

Anda juga bisa mengimplementasikan versi Nullable Anda:

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;
    }
}

Contoh:

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
    }
}

Saya mengalami masalah ini untuk kasus sederhana yang menginginkan metode statis generik yang dapat mengambil apa pun "nullable" (baik jenis referensi atau Nullables), yang membawa saya ke pertanyaan ini tanpa solusi yang memuaskan. Jadi saya datang dengan solusi saya sendiri yang relatif lebih mudah untuk dipecahkan daripada pertanyaan yang dinyatakan OP dengan hanya memiliki dua metode kelebihan beban, satu yang mengambil Tdan memiliki kendala where T : classdan yang lain yang mengambil T?dan memiliki where T : struct.

Saya kemudian menyadari, solusi itu juga dapat diterapkan pada masalah ini untuk membuat solusi yang dapat diperiksa pada waktu kompilasi dengan membuat konstruktor pribadi (atau dilindungi) dan menggunakan metode pabrik statis:

    //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);
        }
    }

Sekarang kita bisa menggunakannya seperti ini:

        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

Jika Anda menginginkan konstruktor tanpa parameter, Anda tidak akan mendapatkan kelebihan beban, tetapi Anda masih dapat melakukan sesuatu seperti ini:

    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?>();
        }
    }

Dan gunakan seperti ini:

        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

Ada beberapa kelemahan dari solusi ini, salah satunya adalah Anda mungkin lebih suka menggunakan 'baru' untuk membuat objek. Lain adalah bahwa Anda tidak akan dapat menggunakan Foo<T>sebagai jenis argumen generik untuk jenis kendala sesuatu seperti: where TFoo: new(). Terakhir adalah sedikit kode tambahan yang Anda butuhkan di sini yang akan meningkat terutama jika Anda membutuhkan banyak konstruktor yang kelebihan beban.

Seperti yang disebutkan, Anda tidak dapat memiliki pemeriksaan waktu kompilasi untuk itu. Batasan umum di .NET sangat kurang, dan tidak mendukung sebagian besar skenario.

Namun saya menganggap ini sebagai solusi yang lebih baik untuk pemeriksaan run-time. Ini dapat dioptimalkan pada waktu kompilasi JIT, karena keduanya adalah konstanta.

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);
    }
}

Batasan tipe seperti itu tidak mungkin. Menurut dokumentasi batasan tipe, tidak ada batasan yang menangkap tipe referensi dan nullable. Karena batasan hanya dapat digabungkan, tidak ada cara untuk membuat batasan seperti itu dengan kombinasi.

Namun, Anda dapat, untuk kebutuhan Anda, kembali ke parameter tipe yang tidak dibatasi, karena Anda selalu dapat memeriksa == null. Jika tipe adalah tipe nilai, pemeriksaan hanya akan selalu bernilai salah. Kemudian Anda mungkin akan mendapatkan peringatan R # "Kemungkinan perbandingan tipe nilai dengan null", yang tidak penting, selama semantiknya tepat untuk Anda.

Alternatif bisa digunakan

object.Equals(value, default(T))

alih-alih pemeriksaan null, karena default (T) di mana T: class selalu null. Ini, bagaimanapun, berarti bahwa Anda tidak dapat membedakan cuaca, nilai yang tidak dapat dinihilkan tidak pernah ditetapkan secara eksplisit atau hanya disetel ke nilai defaultnya.

saya menggunakan

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();