Der Typ 'T' muss ein null-Wert geben, um es zu verwenden als parameter " T "in der generischen Typ oder Methode" System.Nullable<T>'

Warum erhalte ich diesen Fehler im folgenden code?

void Main()
{
    int? a = 1;
    int? b = AddOne(1);
    a.Dump();
}

static Nullable<int> AddOne(Nullable<int> nullable)
{
    return ApplyFunction<int, int>(nullable, (int x) => x + 1);
}

static Nullable<T> ApplyFunction<T, TResult>(Nullable<T> nullable, Func<T, TResult> function)
{
    if (nullable.HasValue)
    {
        T unwrapped = nullable.Value;
        TResult result = function(unwrapped);
        return new Nullable<TResult>(result);
    }
    else
    {
        return new Nullable<T>();
    }
}

Und was ist die Frage??
Nicht überprüfen kann es sofort, aber Sie rufen ApplyFunction<int, int> statt ApplyFunction<int?, int>?
Warum downvotes? Scheint wie eine Frage Klang für mich.

InformationsquelleAutor Clive | 2013-05-24

c#generics nullable

11

Gibt es mehrere Probleme mit dem code. Die erste ist, dass Ihr Typen müssen null-Werte zulassen. Kann man Ausdrücken, dass durch die Angabe where T: struct. Sie müssen auch angeben where TResult: struct da Sie, als eine null zu geben.

Sobald Sie beheben die where T: struct where TResult: struct müssen Sie auch ändern Sie den Typ des Rückgabewertes (was falsch war) und eine Reihe von anderen Dingen auch.

Nach dem beheben aller Fehler und zu vereinfachen, werden Sie wind-up mit dieser:
```
static TResult? ApplyFunction<T, TResult>(T? nullable, Func<T, TResult> function)
                where T: struct 
                where TResult: struct
{
    if (nullable.HasValue)
        return function(nullable.Value);
    else
        return null;
}
```
Beachten Sie, dass Sie schreiben können Nullable<T> als T? was macht die Sache besser lesbar.

Auch Sie könnte schreiben, wie eine Aussage mit ?: aber ich glaube nicht, dass es so lesbar:
```
return nullable.HasValue ? (TResult?) function(nullable.Value) : null;
```
Möchten Sie vielleicht, um diese in eine extension-Methode:
```
public static class NullableExt
{
    public static TResult? ApplyFunction<T, TResult>(this T? nullable, Func<T, TResult> function)
        where T: struct
        where TResult: struct
    {
        if (nullable.HasValue)
            return function(nullable.Value);
        else
            return null;
    }
}
```
Dann schreiben Sie code wie diesen:
```
int? x = 10;
double? x1 = x.ApplyFunction(i => Math.Sqrt(i));
Console.WriteLine(x1);

int? y = null;
double? y1 = y.ApplyFunction(i => Math.Sqrt(i));
Console.WriteLine(y1);
```
Statt zu schreiben new TResult?(), ist es nicht mehr klar, schreib einfach null? Das ist die Philosophie des Nullable<>, denke ich.
Es ist sicher. Ich werde zu aktualisieren. 🙂
Anstatt: return null-Werte zu.HasValue ? (TResult?) Funktion(null-Werte zu.Wert) : null; Sie tun konnte, zurück, der null zulässt??null; das ist ein bisschen schöner und besser lesbar
Wie begründet function() aufgerufen?
Sorry falsch gelesen der Linie, du hast Recht, wenn Sie wollen, um eine Funktion aufzurufen, wird nicht funktionieren

InformationsquelleAutor Matthew Watson
6

Wie der Fehler schon sagt, hat der compiler keine Garantie, dass T nicht bereits null sein. Sie müssen hinzufügen eine Einschränkung T:
```
static Nullable<T> ApplyFunction<T, TResult>(Nullable<T> nullable, 
    Func<T, TResult> function) : where T : struct 
                                 where TResult : struct
```
Sie müssen mehr änderungen, als dass es funktionieren könnte. Zum Beispiel, TResult werden muss, um eine Struktur zu.
Stimmt, verpasste die TResult? behoben 🙂

InformationsquelleAutor T. Kiley

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.