CA2249 : Utiliser de préférence String.Contains à la place de String.IndexOf

Article
09/07/2023

Propriété	Value
Identificateur de la règle	CA2249
Titre	Utiliser de préférence String.Contains à la place de String.IndexOf
Catégorie	Utilisation
Le correctif est cassant ou non cassant	Sans rupture
Activée par défaut dans .NET 9	À titre de suggestion

Cause

Cette règle localise les appels à IndexOf où le résultat est utilisé pour vérifier la présence ou l’absence d’une sous-chaîne, et suggère d’utiliser Contains à la place pour améliorer la lisibilité.

Description de la règle

Quand IndexOf est utilisé pour vérifier si le résultat est égal ou supérieur à -1 ou égal à 0, l’appel peut être remplacé par Contains en toute sécurité sans que cela n’affecte les performances.

Selon la surcharge IndexOf utilisée, le correctif suggéré peut obtenir un argument comparisonType ajouté :

Surcharge	Correctif suggéré
`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)`*

* Toute valeur d’énumération StringComparison autre que StringComparison.Ordinal :

Comment corriger les violations

La violation peut être corrigée soit manuellement, soit dans certains cas à l’aide d’actions rapides pour corriger le code dans Visual Studio.

Exemples

Les deux extraits de code suivants montrent toutes les violations possibles de la règle en C# et comment les corriger :

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.");
        }
    }
}

Conseil

Un correctif de code est disponible pour cette règle dans Visual Studio. Pour l’utiliser, positionnez le curseur sur la violation et appuyez sur Ctrl+. (point). Choisissez Envisager d’utiliser « String.Contains » au lieu de « String.IndexOf » dans la liste des options présentées.

Correctif de code pour CA2249 – Envisager d’utiliser « String.Contains » au lieu de « String.IndexOf »

Quand supprimer les avertissements

Vous pouvez supprimer une violation de cette règle en toute sécurité si l’amélioration de la lisibilité du code ne constitue pas un problème.

Supprimer un avertissement

Si vous voulez supprimer une seule violation, ajoutez des directives de préprocesseur à votre fichier source pour désactiver et réactiver la règle.

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

Pour désactiver la règle sur un fichier, un dossier ou un projet, définissez sa gravité sur none dans le fichier de configuration.

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

Pour plus d’informations, consultez Comment supprimer les avertissements de l’analyse de code.

Voir aussi

Règles d’utilisation

Partager via