CA2016: inoltrare il parametro CancellationToken ai metodi che accettano uno

Causa

Questa regola individua le chiamate al metodo che potrebbero accettare un CancellationToken parametro, ma non vengono passate e suggerisce di inoltrarle al metodo CancellationToken padre.

Descrizione regola

Questa regola analizza le definizioni dei metodi che accettano CancellationToken come ultimo parametro, quindi analizza tutti i metodi richiamati nel corpo. Se una delle chiamate al metodo può accettare come CancellationToken ultimo parametro o avere un overload che accetta come CancellationToken ultimo parametro, la regola suggerisce invece di usare tale opzione per assicurarsi che la notifica di annullamento venga propagata a tutte le operazioni che possono essere in ascolto.

Come correggere le violazioni

È possibile correggere manualmente le violazioni o usare la correzione del codice disponibile in Visual Studio. Passare il puntatore del mouse sulla lampadina visualizzata accanto alla chiamata al metodo e selezionare la modifica suggerita.

L'esempio seguente mostra due modifiche suggerite:

È possibile eliminare una violazione di questa regola se non si è preoccupati di inoltrare la notifica dell'operazione annullata alle chiamate al metodo inferiore. È anche possibile passare default in modo esplicito C# (Nothing in Visual Basic) o None per eliminare la violazione della regola.

La regola può rilevare un'ampia gamma di violazioni. Gli esempi seguenti illustrano i casi in cui la regola può rilevare:

Esempio 1

La regola suggerisce l'inoltro del c parametro da MyMethod alla MyMethodWithDefault chiamata, perché il metodo definisce un parametro di token facoltativo:

using System.Threading;

namespace ConsoleApp
{
    public static class MyTestClass
    {
        public static void MyMethodWithDefault(CancellationToken ct = default)
        {
        }

        public static void MyMethod(CancellationToken c)
        {
            MyMethodWithDefault();
        }
    }
}

Correzione:

Inoltrare il c parametro :

        public static void MyMethod(CancellationToken c)
        {
            MyMethodWithDefault(c);
        }

Se non si è interessati all'inoltro delle notifiche di annullamento a chiamate inferiori, è possibile:

Passare defaultin modo esplicito :

        public static void MyMethod(CancellationToken c)
        {
            MyMethodWithDefault(default);
        }

Oppure passare CancellationToken.Nonein modo esplicito :

        public static void MyMethod(CancellationToken c)
        {
            MyMethodWithDefault(CancellationToken.None);
        }

Esempio 2

La regola suggerisce l'inoltro del c parametro da MyMethod alla MyMethodWithOverload chiamata, perché il metodo ha un overload che accetta un CancellationToken parametro:

using System.Threading;

namespace ConsoleApp
{
    public static class MyTestClass
    {
        public static void MyMethodWithOverload()
        {
        }

        public static void MyMethodWithOverload(CancellationToken ct = default)
        {
        }

        public static void MyMethod(CancellationToken c)
        {
            MyMethodWithOverload();
        }
    }
}

Correzione:

Inoltrare il c parametro :

        public static void MyMethod(CancellationToken c)
        {
            MyMethodWithOverload(c);
        }

Se non si è interessati all'inoltro delle notifiche di annullamento a chiamate inferiori, è possibile:

Passare defaultin modo esplicito :

        public static void MyMethod(CancellationToken c)
        {
            MyMethodWithOverload(default);
        }

Oppure passare CancellationToken.Nonein modo esplicito :

        public static void MyMethod(CancellationToken c)
        {
            MyMethodWithOverload(CancellationToken.None);
        }

Esempi di non violazione

Il CancellationToken parametro nel metodo padre non si trova nell'ultima posizione:

using System.Threading;

namespace ConsoleApp
{
    public static class MyTestClass
    {
        public static void MyMethodWithDefault(CancellationToken ct = default)
        {
        }

        public static void MyMethod(CancellationToken c, int lastParameter)
        {
            MyMethodWithDefault();
        }
    }
}

Il CancellationToken parametro nel metodo predefinito non si trova nell'ultima posizione:

using System.Threading;

namespace ConsoleApp
{
    public static class MyTestClass
    {
        public static void MyMethodWithDefault(CancellationToken ct = default, int lastParameter = 0)
        {
        }

        public static void MyMethod(CancellationToken c)
        {
            MyMethodWithDefault();
        }
    }
}

Il CancellationToken parametro nel metodo di overload non si trova nell'ultima posizione:

using System.Threading;

namespace ConsoleApp
{
    public static class MyTestClass
    {
        public static void MyMethodWithOverload(int lastParameter)
        {
        }
        public static void MyMethodWithOverload(CancellationToken ct, int lastParameter)
        {
        }

        public static void MyMethod(CancellationToken c)
        {
            MyMethodWithOverload();
        }
    }
}

Il metodo padre definisce più di un CancellationToken parametro:

using System.Threading;

namespace ConsoleApp
{
    public static class MyTestClass
    {
        public static void MyMethodWithDefault(CancellationToken ct = default)
        {
        }

        public static void MyMethod(CancellationToken c1, CancellationToken c2)
        {
            MyMethodWithDefault();
        }
    }
}

Il metodo con valori predefiniti definisce più di un CancellationToken parametro:

using System.Threading;

namespace ConsoleApp
{
    public static class MyTestClass
    {
        public static void MyMethodWithDefault(CancellationToken c1 = default, CancellationToken c2 = default)
        {
        }

        public static void MyMethod(CancellationToken c)
        {
            MyMethodWithDefault();
        }
    }
}

L'overload del metodo definisce più di un CancellationToken parametro:

using System.Threading;

namespace ConsoleApp
{
    public static class MyTestClass
    {
        public static void MyMethodWithOverload(CancellationToken c1, CancellationToken c2)
        {
        }

        public static void MyMethodWithOverload()
        {
        }

        public static void MyMethod(CancellationToken c)
        {
            MyMethodWithOverload();
        }
    }
}

Eliminare un avviso

Se si vuole eliminare una singola violazione, aggiungere direttive del preprocessore al file di origine per disabilitare e quindi riabilitare la regola.

#pragma warning disable CA2016
// The code that's violating the rule is on this line.
#pragma warning restore CA2016

Per disabilitare la regola per un file, una cartella o un progetto, impostarne la gravità none su nel file di configurazione.

[*.{cs,vb}]
dotnet_diagnostic.CA2016.severity = none

Per altre informazioni, vedere Come eliminare gli avvisi di analisi del codice.