CA2249: Considerar o uso de String.Contains em vez de String.IndexOf

Artigo
09/07/2023

Property	Valor
ID da regra	CA2249
Título	Considerar o uso de String.Contains em vez de String.IndexOf
Categoria	Usage
Correção interruptiva ou sem interrupção	Sem interrupção
Habilitado por padrão no .NET 9	Como sugestão

Causa

Essa regra localiza as chamadas para IndexOf em que o resultado é usado para verificar a presença ou a ausência de uma substring e sugere o uso de Contains para melhorar a legibilidade.

Descrição da regra

Quando IndexOf for usado para verificar se o resultado é igual a -1 ou maior ou igual a 0, a chamada poderá ser substituída com segurança por Contains sem afetar o desempenho.

Dependendo da sobrecarga de IndexOf que está sendo usada, a correção sugerida poderá obter um argumento comparisonType 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)`*

* Valor de enumeração StringComparison 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 snippets 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.");
        }
    }
}

Dica

Uma correção de código está disponível para essa regra no Visual Studio. Para usá-la, posicione o cursor sobre a violação e pressione Ctrl+. (ponto). Escolha considerar o uso de 'String.Contains' em vez de 'String.IndexOf' da lista de opções apresentadas.

Correção de código para CA2249: considerar o uso de 'String.Contains' em vez de 'String.IndexOf'

Quando suprimir avisos

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

Suprimir um aviso

Para suprimir apenas uma violação, adicione diretivas de pré-processador ao arquivo de origem a fim de desabilitar e, em seguida, reabilitar 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 em um arquivo, uma pasta ou um projeto, defina a severidade como none no arquivo de configuração.

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

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

Confira também

Regras de uso

Compartilhar via