Le type " T "doit être un non nullable type de valeur afin de l'utiliser comme paramètre" T " dans le générique du type ou de la méthode 'Système.Nullable<T>'

Pourquoi j'obtiens cette erreur dans le code suivant?

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>();
    }
}
Et quelle est la question??
Ne peut pas le tester dès maintenant, mais vous appelez ApplyFunction<int, int> au lieu de ApplyFunction<int?, int>?
Pourquoi les downvotes? Semble comme un son de question pour moi.

OriginalL'auteur Clive | 2013-05-24

  1. 11

    Il y a plusieurs problèmes avec le code. La première est que votre types nullables. Vous pouvez exprimer que, en spécifiant where T: struct. Vous devrez également spécifier where TResult: struct parce que vous l'utilisez comme un type nullable trop.

    Une fois que vous résoudre le where T: struct where TResult: struct vous devez également modifier la valeur de retour de type (ce qui était faux) et un certain nombre d'autres choses aussi.

    Après la fixation de toutes ces erreurs et de la simplification, de vous retrouver avec ceci:

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

    Notez que vous pouvez réécrire Nullable<T> comme T? ce qui rend les choses plus lisibles.

    Aussi vous avez pu écrire que comme une seule instruction à l'aide de ?: mais je ne pense pas que c'est aussi lisible:

    return nullable.HasValue ? (TResult?) function(nullable.Value) : null;

    Vous pourriez mettre dans une méthode d'extension:

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

    Ensuite, vous pouvez écrire du code comme ceci:

    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);
    Au lieu d'écrire new TResult?(), n'est-il pas plus clair pour tout écrire null? C'est la philosophie de Nullable<>, je suppose.
    Il est sûr. Je vais mettre à jour. 🙂
    Au lieu de: retour nullable.HasValue ? (TResult?) fonction(nullable.Valeur) : null; vous pourriez le faire revenir nullable??null; ce qui est un peu plus agréable et plus lisible
    Comment alors ne function() appelée?
    Désolé mal lu la ligne, vous avez raison, si vous voulez appeler une fonction qui ne fonctionne pas

    OriginalL'auteur Matthew Watson

  2. 6

    Que l'erreur l'indique, le compilateur n'a aucune garantie que T ne pas déjà être nullable. Vous avez besoin d'ajouter une contrainte à T:

    static Nullable<T> ApplyFunction<T, TResult>(Nullable<T> nullable, 
    Func<T, TResult> function) : where T : struct 
                                 where TResult : struct
    Vous aurez besoin de plus de changements que cela pour le faire fonctionner. Par exemple, TResult doit être une structure trop.
    Vrai, incontournable de la TResult? fixe 🙂

    OriginalL'auteur T. Kiley