CA2249: Considere usar String.Contains em vez de String.IndexOf

Artigo
12/16/2023

Property	valor
ID da regra	CA2249
Título	Considere usar String.Contains em vez de String.IndexOf
Categoria	Utilização
A correção está quebrando ou não quebrando	Sem quebra
Habilitado por padrão no .NET 8	Como sugestão

Motivo

Esta regra localiza chamadas para onde o resultado é usado para verificar a presença ou ausência de uma substring, e sugere o uso Contains em vez disso, para IndexOf melhorar a legibilidade.

Descrição da regra

Quando IndexOf é usado para verificar se o resultado é igual ou -1 maior ou igual a , a 0chamada pode ser substituída com segurança sem Contains um impacto no desempenho.

Dependendo da IndexOf sobrecarga que está sendo usada, a correção sugerida pode obter um comparisonType argumento adicionado:

Sobrecarga	Correção sugerida
`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)`*

* Qualquer StringComparison valor de enum diferente de StringComparison.Ordinal:

Como corrigir violações

A violação pode ser corrigida manualmente ou, em alguns casos, usando ações rápidas para corrigir o código no Visual Studio.

Exemplos

Os dois trechos de código a seguir mostram todas as possíveis violações da regra em C# e como corrigi-las:

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

Gorjeta

Uma correção de código está disponível para essa regra no Visual Studio. Para usá-lo, posicione o cursor sobre a violação e pressione Ctrl+. Escolha Considerar o uso de 'string. Contém' em vez de 'string. IndexOf' da lista de opções apresentada.

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

Quando suprimir avisos

É seguro suprimir uma violação desta regra se melhorar a legibilidade do código não for uma preocupação.

Suprimir um aviso

Se você quiser apenas suprimir uma única violação, adicione diretivas de pré-processador ao seu arquivo de origem para desativar e, em seguida, reativar a regra.

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

Para desabilitar a regra para um arquivo, pasta ou projeto, defina sua severidade como none no arquivo de configuração.

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

Para obter mais informações, consulte Como suprimir avisos de análise de código.

Consulte também

Regras de utilização

Partilhar via