CA2249: Överväg att använda String.Contains i stället för String.IndexOf

Property	Värde
Regel-ID	CA2249
Title	Överväg att använda String.Contains i stället för String.IndexOf
Kategori	Användning
Korrigeringen är icke-bakåtkompatibel	Icke-icke-bryta
Aktiverad som standard i .NET 8	Som förslag

Orsak

Den här regeln letar upp anrop till IndexOf där resultatet används för att söka efter förekomsten eller frånvaron av en delsträng, och föreslår att du i stället använder Contains för att förbättra läsbarheten.

Regelbeskrivning

När IndexOf används för att kontrollera om resultatet är lika -1 med eller större eller lika 0med kan anropet på ett säkert sätt ersättas med Contains utan att prestanda påverkas.

Beroende på den IndexOf överlagring som används kan den föreslagna korrigeringen få ett comparisonType argument tillagt:

Överbelastning	Föreslagen korrigering
String.IndexOf(char)	String.Contains(char)
String.IndexOf(string)	String.Contains(string, StringComparison.CurrentCulture)
String.IndexOf(char, StringComparison.Ordinal)	String.Contains(char)
String.IndexOf(string, StringComparison.Ordinal)	String.Contains(string)
String.IndexOf(char, NON StringComparison.Ordinal)*	String.Contains(char, NON StringComparison.Ordinal)*
String.IndexOf(string, NON StringComparison.Ordinal)*	String.Contains(string, NON StringComparison.Ordinal)*

* Alla StringComparison uppräkningsvärden förutom StringComparison.Ordinal:

• CurrentCulture
• CurrentCultureIgnoreCase
• InvariantCulture
• InvariantCultureIgnoreCase
• OrdinalIgnoreCase

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

Överträdelsen kan antingen åtgärdas manuellt eller i vissa fall med hjälp av snabbåtgärder för att åtgärda kod i Visual Studio.

Exempel

Följande två kodfragment visar alla möjliga överträdelser av regeln i C# och hur du åtgärdar dem:

using System;

class MyClass
{
    void MyMethod()
    {
        string str = "My text";
        bool found;

        // No comparisonType in char overload, so no comparisonType added in resulting fix
        found = str.IndexOf('x') == -1;
        found = str.IndexOf('x') >= 0;

        // No comparisonType in string overload, adds StringComparison.CurrentCulture to resulting fix
        found = str.IndexOf("text") == -1;
        found = str.IndexOf("text") >= 0;

        // comparisonType equal to StringComparison.Ordinal, removes the argument
        found = str.IndexOf('x', StringComparison.Ordinal) == -1;
        found = str.IndexOf('x', StringComparison.Ordinal) >= 0;

        found = str.IndexOf("text", StringComparison.Ordinal) == -1;
        found = str.IndexOf("text", StringComparison.Ordinal) >= 0;

        // comparisonType different than StringComparison.Ordinal, preserves the argument
        found = str.IndexOf('x', StringComparison.OrdinalIgnoreCase) == -1;
        found = str.IndexOf('x', StringComparison.CurrentCulture) >= 0;

        found = str.IndexOf("text", StringComparison.InvariantCultureIgnoreCase) == -1;
        found = str.IndexOf("text", StringComparison.InvariantCulture) >= 0;

        // Suggestion message provided, but no automatic fix offered, must be fixed manually
        int index = str.IndexOf("text");
        if (index == -1)
        {
            Console.WriteLine("'text' Not found.");
        }
    }
}

using System;

class MyClass
{
    void MyMethod()
    {
        string str = "My text";
        bool found;

        // No comparisonType in char overload, so no comparisonType added in resulting fix
        found = !str.Contains('x');
        found = str.Contains('x');

        // No comparisonType in string overload, adds StringComparison.CurrentCulture to resulting fix
        found = !string.Contains("text", StringComparison.CurrentCulture);
        found = string.Contains("text", StringComparison.CurrentCulture);

        // comparisonType equal to StringComparison.Ordinal, removes the argument
        found = !string.Contains('x');
        found = string.Contains('x');

        found = !string.Contains("text");
        found = string.Contains("text");

        // comparisonType different than StringComparison.Ordinal, preserves the argument
        ;found = !string.Contains('x', StringComparison.OrdinalIgnoreCase)
        found = string.Contains('x', StringComparison.CurrentCulture);

        found = !string.Contains("text", StringComparison.InvariantCultureIgnoreCase);
        found = string.Contains("text", StringComparison.InvariantCulture);

        // This case had to be manually fixed
        if (!str.Contains("text"))
        {
            Console.WriteLine("'text' Not found.");
        }
    }
}

Dricks

En kodkorrigering är tillgänglig för den här regeln i Visual Studio. Om du vill använda den placerar du markören på överträdelsen och trycker på Ctrl+. (punkt). Välj Överväg att använda sträng. Innehåller i stället för sträng. IndexOf från listan över alternativ som visas.

När du ska ignorera varningar

Det är säkert att förhindra en överträdelse av den här regeln om det inte är något problem att förbättra kodens läsbarhet.

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 CA2249
// The code that's violating the rule is on this line.
#pragma warning restore CA2249

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.CA2249.severity = none

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

Se även

• Användningsregler