CA2016: Vidarebefordra parametern CancellationToken till metoder som tar en

Orsak

Den här regeln letar upp metodanrop som kan acceptera en CancellationToken parameter, men som inte skickar några, och föreslår att den överordnade metoden vidarebefordras CancellationToken till dem.

Regelbeskrivning

Den här regeln analyserar metoddefinitioner som tar en CancellationToken som sin sista parameter och analyserar sedan alla metoder som anropas i dess brödtext. Om någon av metodanropen antingen kan acceptera en CancellationToken som den sista parametern eller ha en överlagring som tar en CancellationToken som den sista parametern, föreslår regeln att du använder det alternativet i stället för att säkerställa att annulleringsmeddelandet sprids till alla åtgärder som kan lyssna på den.

Så här åtgärdar du överträdelser

Du kan antingen åtgärda överträdelser manuellt eller använda den kodkorrigering som är tillgänglig i Visual Studio. Hovra över glödlampan som visas bredvid metodanropet och välj den föreslagna ändringen.

I följande exempel visas två föreslagna ändringar:

Det är säkert att förhindra en överträdelse av den här regeln om du inte bryr dig om att vidarebefordra meddelandet om avbruten åtgärd till lägre metodanrop. Du kan också uttryckligen skicka default C# (Nothing i Visual Basic) eller None för att förhindra regelöverträdelsen.

Regeln kan identifiera en mängd olika överträdelser. Följande exempel visar fall som regeln kan identifiera:

Exempel 1

Regeln föreslår att parametern ct vidarebefordras från MyMethod till anropet MyMethodWithDefault , eftersom metoden definierar en valfri tokenparameter:

using System.Threading;

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

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

Lösningen

Vidarebefordra parametern ct :

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

Om du inte bryr dig om att vidarebefordra avbokningsmeddelanden till lägre anrop kan du antingen:

defaultSkicka uttryckligen :

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

Eller skicka CancellationToken.Noneuttryckligen :

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

Exempel 2

Regeln föreslår att parametern ct vidarebefordras från MyMethod till anropet MyMethodWithOverload , eftersom metoden har en överlagring som tar en CancellationToken parameter:

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 ct)
        {
            MyMethodWithOverload();
        }
    }
}

Lösningen

Vidarebefordra parametern ct :

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

Om du inte bryr dig om att vidarebefordra avbokningsmeddelanden till lägre anrop kan du antingen:

defaultSkicka uttryckligen :

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

Eller skicka CancellationToken.Noneuttryckligen :

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

Exempel på icke-överträdelse

Parametern CancellationToken i den överordnade metoden är inte i den sista positionen:

using System.Threading;

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

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

Parametern CancellationToken i standardmetoden är inte i den sista positionen:

using System.Threading;

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

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

Parametern CancellationToken i överlagringsmetoden är inte i den sista positionen:

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 ct)
        {
            MyMethodWithOverload();
        }
    }
}

Den överordnade metoden definierar mer än en CancellationToken parameter:

using System.Threading;

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

        public static void MyMethod(CancellationToken ct1, CancellationToken ct2)
        {
            MyMethodWithDefault();
        }
    }
}

Metoden med standardvärden definierar mer än en CancellationToken parameter:

using System.Threading;

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

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

Metodens överlagring definierar mer än en CancellationToken parameter:

using System.Threading;

namespace ConsoleApp
{
    public static class MyTestClass
    {
        public static void MyMethodWithOverload(CancellationToken ct1, CancellationToken ct2)
        {
        }

        public static void MyMethodWithOverload()
        {
        }

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

Ignorera en varning

Om du bara vill förhindra en enda överträdelse lägger du till förprocessordirektiv i källfilen för att inaktivera och aktiverar sedan regeln igen.

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

Om du vill inaktivera regeln för en fil, mapp eller ett projekt anger du dess allvarlighetsgrad till none i konfigurationsfilen.

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

Mer information finns i Så här utelämnar du kodanalysvarningar.