Parâmetro padrão para CancelamentoToken

Tenho um código assíncrono ao qual gostaria de adicionar um CancellationToken. No entanto, existem muitas implementações onde isso não é necessário, então eu gostaria de ter um parâmetro padrão - talvezCancellationToken.None . Contudo,

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

rendimentos

Um valor do tipo '' não pode ser usado como parâmetro padrão porque não há conversões padrão para o tipo 'System.Threading.CancellationToken'

e

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

O valor do parâmetro padrão para 'ct' deve ser uma constante de tempo de compilação

Existe alguma maneira de ter um valor padrão para CancellationToken?

Acontece que o seguinte funciona:

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

que, de acordo com a documentação , é interpretado da mesma forma que CancellationToken.None:

Você também pode usar a default(CancellationToken)instrução C # para criar um token de cancelamento vazio.

Existe alguma maneira de ter um valor padrão para CancelamentoToken?

Infelizmente, isso não é possível, pois CancellationToken.Nonenão é uma constante de tempo de compilação, que é um requisito para valores padrão em argumentos opcionais.

Você pode fornecer o mesmo efeito, no entanto, criando um método sobrecarregado em vez de tentar usar os parâmetros padrão:

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

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

Aqui estão várias soluções, em ordem decrescente de bondade geral:

1. Usando default(CancellationToken)como valor padrão:

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

Semanticamente, CancellationToken.Noneseria o candidato ideal para o padrão, mas não pode ser usado como tal porque não é uma constante de tempo de compilação. default(CancellationToken)é a próxima melhor coisa porque é uma constante de tempo de compilação e oficialmente documentada para ser equivalente aCancellationToken.None .

2. Fornecer uma sobrecarga de método sem um CancellationTokenparâmetro:

Ou, se você preferir sobrecargas de método em vez de parâmetros opcionais (consulte esta e esta pergunta sobre esse tópico):

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

Para métodos de interface, o mesmo pode ser alcançado usando métodos de extensão:

interface IFoo
{
    Task DoAsync(CancellationToken ct);
}

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

Isso resulta em uma interface mais estreita e evita que os implementadores gravem explicitamente a sobrecarga do método de encaminhamento.

3. Tornando o parâmetro anulável e usando nullcomo valor padrão:

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

Gosto menos dessa solução porque os tipos anuláveis ​​vêm com uma pequena sobrecarga de tempo de execução e as referências ao token de cancelamento se tornam mais detalhadas por causa do operador de coalescência nulo ??.

Outra opção é usar um Nullable<CancellationToken>parâmetro, padronizá-lo nulle lidar com ele dentro do método:

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

As versões mais recentes do C # permitem uma sintaxe simplificada para a versão padrão (CancelamentoToken). Por exemplo:

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

A resposta de Tofutim é uma maneira, mas pelos comentários vejo que as pessoas têm problemas com isso.

Nesse caso, sugeri que se pode ter um método como segue:

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

e sobrecarregá-lo como:

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

Isso compila, porque o valor de CancellationToken.Nonenão é necessário no momento da compilação.