Beschränken, allgemein zu werden eine nullable-Typ

Ich bin auf der Suche zum Beispiel etwas wie:

Foo<string> stringFoo = new Foo<string>("The answer is");
Foo<int> intFoo = new Foo<int>(42);
//The Value of intFoo & stringFoo are strongly typed
stringFoo.Nullify();
intFoo.Nullify();
if (stringFoo == null && intFoo == null)
   MessageBox.Show("Both are null);

Diese Klasse Foo, ich kann auto-wrap-T in eine durch null-Werte zulässt:

public class Foo1<T>
   where T : struct
{
   private T? _value;

   public Foo(T? initValue)
   {
      _value = initValue;
   }

   public T? Value { get { return _value; } }

   public void Nullify { _value = null; }

}

Diese funktioniert bei den primitiven, aber nicht mit einer Schnur oder anderen Klassen.

Nächsten Aroma-Werke für Streicher, aber nicht primitive:

public class Foo2<T>
{
   private T _value;

   public Foo(T initValue)
   {
      _value = initValue;
   }

   public T Value { get { return _value; } }

   public void Nullify { _value = default(T); }

}

Könnte ich Nullable<int> für Foo2 und der code würde arbeiten wie diese:

Foo2<int?> intFoo = new Foo<int?>(42);

Aber das ist fehleranfällig, weil es nicht für Foo2. Wenn ich könnte einschränken, dass T-Typen unterstützen null-Zulässigkeit, dann wäre das in Ordnung.

So, nachdem alle, die, gibt es eine Möglichkeit zu beschränken, dass T ein nullable-Typ?

Zusätzliche Hinweise: .NET 4.0, VS2010. Und ich habe eine ähnliche Frage wie diese hier, aber ohne eine erfolgreiche Antwort.

InformationsquelleAutor der Frage tcarvin | 2013-02-15

  1. 9

    Könnten Sie in der Lage sein, um den Konstruktor der Foo<T> internen und erfordern, dass neue Instanzen können nur über eine factory-Klasse:

    public class Foo<T>
{
    private T value;
    internal Foo(T value)
    {
        this.value = value;
    }

    public void Nullify()
    {
        this.value = default(T);
    }

    public T Value { get { return this.value; } }
}

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

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

    InformationsquelleAutor der Antwort Lee

  2. 18

    Gibt es keine Einschränkung, die Sie anwenden können, für diese, aber Sie kann test für ihn bei der Ausführung:

    if (default(T) != null)
{
    throw new SomeAppropriateException(typeof(T) + " is not a nullable type");
}

    Du könntest sogar, dass in einem statischen Konstruktor, der das machen würde, sicher, dass Sie nur ausgeführt einmal pro konstruiert geben - und jeden, der versucht zu verwenden Foo<int> überall würde haben eine harte Zeit, ignorieren die TypeInitializerException. Das ist nicht sehr freundlich für ein öffentlichen - API, aber ich denke, es ist vernünftig, für ein internen.

    EDIT: Es ist eine schrecklich Weg, wodurch es schwieriger wird, erstellen Sie Instanzen der Foo<int>... Sie konnte die grausige code in diesem blog-post (mit überlast Auflösung Regeln zusammen mit Standard-Parameter und ein paar von gebundenen und generische Typen) und markieren Sie die überladung, die darauf abzielt, einen null-Wert geben, als veraltet mit einem Fehler. So Foo<int> wäre immer noch eine gültige Art, aber Sie würden sein hart gedrückt, um eine Instanz davon erstellt werden. Ich werde nicht empfehlen Ihnen, dies zu tun, obwohl...

    InformationsquelleAutor der Antwort Jon Skeet

  3. 0

    Ich mag es nicht so viel wie die syntax von Foo1, aber hier ist Foo3:

    public class Foo3<T>
   where T : struct
{

   private T _value;
   private T _nullValue;

   public Foo3(T initValue)
       : this(initValue, default(T))
   {
   }

   public Foo3(T initValue, T nullValue)
   {
      _value = initValue;
      _nullValue = nullValue;
   }

   public T Value { get { return _value; } }

    public bool IsNull
    {
        get 
        {
           return object.Equals(_value, _nullValue);
        }
    }

    public void Nullify() { _value = _nullValue; }

}

    Dann meine Auslastung wird:

    Foo3<string> stringFoo = new Foo<string>("The answer is");
Foo3<int> intFoo = new Foo<int>(42, int.MinValue);
stringFoo.Nullify();
intFoo.Nullify();
if (stringFoo.IsNull && intFoo.IsNull)
   MessageBox.Show("Both are null);

    Dies ist immer noch fehleranfällig, da immer die Value-Eigenschaft von Foo3 (und Foo2) ist nicht einfach. Foo1 war die beste, weil automatisch umgebrochen, so wird der Wert null Unterstützung.

    Könnte ich gerade brauchen, ValueTypeFoo und ObjectFoo und den Umgang mit zwei versons.

    InformationsquelleAutor der Antwort tcarvin

Schreibe einen Kommentar