Paramètre par défaut pour CancellationToken

J'ai du code asynchrone auquel je voudrais ajouter un CancellationToken. Cependant, il existe de nombreuses implémentations où cela n'est pas nécessaire, je voudrais donc avoir un paramètre par défaut - peut-être CancellationToken.None. cependant,

Task<x> DoStuff(...., CancellationToken ct = null)

rendements

Une valeur de type «» ne peut pas être utilisée comme paramètre par défaut car il n'y a pas de conversion standard pour le type «System.Threading.CancellationToken»

et

Task<x> DoStuff(...., CancellationToken ct = CancellationToken.None)

La valeur du paramètre par défaut pour «ct» doit être une constante de compilation

Existe-t-il un moyen d'avoir une valeur par défaut pour CancellationToken?

Il s'avère que ce qui suit fonctionne:

Task<x> DoStuff(...., CancellationToken ct = default(CancellationToken))

qui, selon la documentation , est interprété de la même manière que CancellationToken.None:

Vous pouvez également utiliser l' default(CancellationToken)instruction C # pour créer un jeton d'annulation vide.

Existe-t-il un moyen d'avoir une valeur par défaut pour CancellationToken?

Malheureusement, cela n'est pas possible, car ce CancellationToken.Nonen'est pas une constante de temps de compilation, qui est une exigence pour les valeurs par défaut dans les arguments facultatifs.

Vous pouvez cependant fournir le même effet en créant une méthode surchargée au lieu d'essayer d'utiliser les paramètres par défaut:

Task<x> DoStuff(...., CancellationToken ct)
{
    //...
}

Task<x> DoStuff(....)
{
    return DoStuff(...., CancellationToken.None);
}

Voici plusieurs solutions, par ordre décroissant de bonté générale:

1. En utilisant default(CancellationToken)comme valeur par défaut:

Task DoAsync(CancellationToken ct = default(CancellationToken)) { … }

Sémantiquement, CancellationToken.Noneserait le candidat idéal pour la valeur par défaut, mais ne peut pas être utilisé en tant que tel car ce n'est pas une constante de compilation. default(CancellationToken)est la prochaine meilleure chose car il s'agit d'une constante de compilation et officiellement documentée comme équivalente àCancellationToken.None .

2. Fournir une surcharge de méthode sans CancellationTokenparamètre:

Ou, si vous préférez les surcharges de méthode aux paramètres facultatifs (voir ceci et cette question sur ce sujet):

Task DoAsync(CancellationToken ct) { … } // actual method always requires a token
Task DoAsync() => DoAsync(CancellationToken.None); // overload producing a default token

Pour les méthodes d'interface, la même chose peut être obtenue en utilisant des méthodes d'extension:

interface IFoo
{
    Task DoAsync(CancellationToken ct);
}

static class Foo
{
    public static Task DoAsync(this IFoo foo) => foo.DoAsync(CancellationToken.None);
}

Cela se traduit par une interface plus mince et évite aux implémenteurs d'écrire explicitement la surcharge de la méthode de transfert.

3. Rendre le paramètre nullable et utiliser nullcomme valeur par défaut:

Task DoAsync(…, CancellationToken? ct = null)
{
    … ct ?? CancellationToken.None …
}

J'aime moins cette solution parce que les types Nullable sont livrés avec une petite surcharge d'exécution, et les références au jeton d'annulation deviennent plus verbeuses en raison de l'opérateur de fusion null ??.

Une autre option consiste à utiliser un Nullable<CancellationToken>paramètre, à le définir par défaut nullet à le gérer dans la méthode:

Task<x> DoStuff(...., CancellationToken? ct = null) {
    var token = ct ?? CancellationToken.None;
    ...
}

Les versions plus récentes de C # permettent une syntaxe simplifiée pour la version par défaut (CancellationToken). Par exemple:

Task<x> DoStuff(...., CancellationToken ct = default)

La réponse de Tofutim est à sens unique, mais d'après les commentaires, je vois que les gens ont des problèmes avec cela.

Dans ce cas, j'ai suggéré que l'on puisse avoir une méthode comme suit:

Task<x> DoStuff(...., CancellationToken ct)
{
} 

et surchargez-le comme:

Task<x> DoStuff(....)
{
    return DoStuff(...., CancellationToken.None);
}

Cela compile, car la valeur de CancellationToken.Nonen'est pas requise au moment de la compilation.