CA2249: Valorar la posibilidad de usar String.Contains en lugar de String.IndexOf

Artículo
06/05/2023

Propiedad	Value
Identificador de la regla	CA2249
Título	Valorar la posibilidad de usar String.Contains en lugar de String.IndexOf
Categoría	Uso
La corrección es problemática o no problemática	Poco problemático
Habilitado de forma predeterminada en .NET 8	Como sugerencia

Causa

Esta regla busca llamadas a IndexOf donde se usa el resultado para comprobar la presencia o ausencia de una subcadena y sugiere usar Contains alternativamente, para mejorar la legibilidad.

Descripción de la regla

Cuando IndexOf se usa para comprobar si el resultado es igual a -1 o mayor o igual que 0, la llamada se puede sustituir por Contains sin ningún impacto en el rendimiento.

En función de la sobrecarga de IndexOf que se use, la corrección sugerida podría obtener un argumento comparisonType agregado:

Sobrecarga	Corrección 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)`*

* Cualquier valor de enumeración StringComparison distinto de StringComparison.Ordinal:

Cómo corregir infracciones

La infracción se puede corregir manualmente o, en algunos casos, se pueden usar acciones rápidas para corregir el código en Visual Studio.

Ejemplos

En los dos fragmentos de código siguientes se muestran todas las posibles infracciones de la regla en C# y cómo corregirlos:

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

Sugerencia

Hay disponible una corrección de código para esta regla en Visual Studio. Para usarla, coloque el cursor sobre la infracción y presione Ctrl+. (punto). Elija Consider using 'string.Contains' instead of 'string.IndexOf' (Valorar la posibilidad de usar "string.Contains" en lugar de "string.IndexOf") en la lista de opciones que se presentan.

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

Cuándo suprimir las advertencias

Resulta seguro suprimir una infracción de esta regla si la mejora de la legibilidad del código no es un problema.

Supresión de una advertencia

Si solo quiere suprimir una única infracción, agregue directivas de preprocesador al archivo de origen para deshabilitar y volver a habilitar la regla.

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

Para deshabilitar la regla de un archivo, una carpeta o un proyecto, establezca su gravedad en none del archivo de configuración.

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

Para obtener más información, consulte Procedimiento para suprimir advertencias de análisis de código.

Consulte también

Reglas de uso

Share via