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

2025-04-22

Egendom	Värde
Regel-ID	CA2249
Titel	Överväg att använda String.Contains i stället för String.IndexOf
Kategori	Användning
Korrigeringen är antingen brytande eller icke-brytande	Obrytbar
Aktiverad som standard i .NET 9	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 med -1 eller större eller lika med 0, kan anropet säkert ersättas med Contains utan att prestandan 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 enum-värden förutom StringComparison.Ordinal:

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 = !str.Contains("text", StringComparison.CurrentCulture);
        found = str.Contains("text", StringComparison.CurrentCulture);

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

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

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

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

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

Tips

En kodkorrigering är tillgänglig för den här regeln i Visual Studio. Om du vill använda den, placera markören på överträdelsen och tryck på Ctrl+. (punkt). Välj överväg att använda 'string.Contains' istället för 'string.IndexOf' från listan över alternativ som visas.

Kodkorrigering för CA2249 – Överväg att använda 'sträng.Contains' i stället för 'sträng.IndexOf'

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.

Undertryck 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

Dela via