C # generischer Typ-Constraint für alle NULL-Werte

Wenn Sie bereit sind, um einen Laufzeit-check-in Foo Konstruktor, anstatt einen compile-time check können Sie überprüfen, ob der Typ nicht einen Verweis oder nullable-Typ, und eine Ausnahme wird ausgelöst, wenn das der Fall ist.

Mir ist klar, dass nur mit einer Laufzeit überprüfen kann inakzeptabel sein, aber nur für den Fall:

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

Dann der folgende code kompiliert werden, aber die Letzte (foo3) wirft eine exception im 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());

InformationsquelleAutor der Antwort Matthew Watson

Ich lief in dieses Problem für einen einfacheren Fall zu wollen, eine statische generische Methode, die könnte etwas "nullable" (entweder Referenz-Typen oder Nullables), die brachte mich auf diese Frage keine zufriedenstellende Lösung. So kam ich mit meiner eigenen Lösung, die relativ leichter zu lösen als die OP genannte Frage, indem Sie einfach mit zwei überladenen Methoden, eine, die eine T und hat die Einschränkung where T : class und einem anderen, das dauert ein T? und hat where T : struct .

Dann erkannte ich, dass die Lösung auch für dieses problem eine Lösung zu schaffen, ist überprüfbar ist zur compile-Zeit durch den Konstruktor private (oder protected) und die Verwendung einer statischen factory-Methode:

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

Nun können wir es wie folgt:

        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

Möchten Sie einen parameterlosen Konstruktor, Sie wird nicht die Feinheit der überlastung, aber man kann immer noch etwas tun, wie dieses:

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

Und verwenden Sie es wie diese:

        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

Gibt es einige Nachteile bei dieser Lösung ist, dass Sie vielleicht lieber mit 'new' zu konstruieren-Objekte. Ein weiterer ist, dass Sie nicht in der Lage sein zu verwenden Foo<T> als generic type Arguments für eine Art Einschränkung der so etwas wie: where TFoo: new(). Schließlich ist das bisschen extra-code, den Sie brauchen, hier die erhöhen würde, vor allem, wenn Sie mehrere überladene Konstruktoren.

InformationsquelleAutor der Antwort Dave M

Wie bereits erwähnt, können Sie nicht über eine compile-time check für Sie. Generische constraints in .NET sind äußerst mangelhaft, und nicht unterstützen, die meisten Szenarien.

Aber ich halte das für eine bessere Lösung für die run-time-Prüfung. Es können optimiert werden auf JIT-Kompilierung-Zeit, da sind Sie beide Konstanten.

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

InformationsquelleAutor der Antwort Aidiakapi

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

InformationsquelleAutor der Antwort SeeSharp