CA2249: prendere in considerazione l'uso di String.Contains invece di String.IndexOf

Articolo
09/06/2023

Proprietà	valore
ID regola	CA2249
Title	Provare a usare String.Contains invece di String.IndexOf
Categoria	Utilizzo
Correzione che causa un'interruzione o un'interruzione	Nessuna interruzione
Abilitato per impostazione predefinita in .NET 8	Come suggerimento

Causa

Questa regola individua le chiamate a IndexOf dove viene usato il risultato per verificare la presenza o l'assenza di una sottostringa e suggerisce invece di usare Contains per migliorare la leggibilità.

Descrizione regola

Quando IndexOf viene usato per verificare se il risultato è uguale o maggiore o uguale 0a -1 , la chiamata può essere sostituita in modo sicuro con Contains senza alcun impatto sulle prestazioni.

A seconda dell'overload IndexOf usato, la correzione suggerita potrebbe ottenere un comparisonType argomento aggiunto:

Overload	Correzione suggerita
`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)`*

* Qualsiasi StringComparison valore di enumerazione diverso da StringComparison.Ordinal:

Come correggere le violazioni

La violazione può essere corretta manualmente o, in alcuni casi, usando Azioni rapide per correggere il codice in Visual Studio.

Esempi

I due frammenti di codice seguenti mostrano tutte le possibili violazioni della regola in C# e come risolverle:

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

Suggerimento

Una correzione del codice è disponibile per questa regola in Visual Studio. Per usarlo, posizionare il cursore sulla violazione e premere CTRL+. (punto). Scegliere Considera l'uso di 'string. Contiene invece di 'string. IndexOf' dall'elenco di opzioni presentate.

Code fix for CA2249 - Consider using 'string.Contains' instead of 'string.IndexOf'

Quando eliminare gli avvisi

È sicuro eliminare una violazione di questa regola se il miglioramento della leggibilità del codice non è un problema.

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

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

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

Vedi anche

Regole di utilizzo

Condividi tramite