CA2249: Erwägen Sie die Verwendung von "String.Contains" anstelle von "String.IndexOf"

Ursache

Diese Regel sucht nach Aufrufen von IndexOf, wo das Ergebnis verwendet wird, um zu überprüfen, ob ein Substring vorhanden oder nicht vorhanden ist. Zudem empfiehlt sie stattdessen die Verwendung von Contains, um die Lesbarkeit zu verbessern.

Regelbeschreibung

Wenn IndexOf verwendet wird, um zu überprüfen, ob das Ergebnis gleich -1 oder größer oder gleich 0 ist, kann der Aufruf sicher durch Contains ersetzt werden, ohne dass sich dies auf die Leistung auswirkt.

Abhängig von der verwendeten Überladung IndexOf könnte für den vorgeschlagenen Fix ein Argument comparisonType hinzugefügt werden:

* Alle StringComparison-Enumerationswerte außer StringComparison.Ordinal:

• CurrentCulture
• CurrentCultureIgnoreCase
• InvariantCulture
• InvariantCultureIgnoreCase
• OrdinalIgnoreCase

Behandeln von Verstößen

Der Verstoß kann entweder manuell behoben werden oder in einigen Fällen durch Quick Actions zum Beheben von Code in Visual Studio.

Beispiele

Die folgenden beiden Codeausschnitte zeigen alle möglichen Verstöße gegen die Regel in C# und wie sie behoben werden:

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

Wann sollten Warnungen unterdrückt werden?

Es ist sicher, einen Verstoß gegen diese Regel zu unterdrücken, wenn das Verbessern der Lesbarkeit von Code nicht relevant ist.

Unterdrücken einer Warnung

Um nur eine einzelne Verletzung zu unterdrücken, fügen Sie der Quelldatei Präprozessoranweisungen hinzu, um die Regel zu deaktivieren und dann wieder zu aktivieren.

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

Um die Regel für eine Datei, einen Ordner oder ein Projekt zu deaktivieren, legen Sie den Schweregrad in der Konfigurationsdatei auf none fest.

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

Weitere Informationen finden Sie unter Vorgehensweise: Unterdrücken von Codeanalyse-Warnungen.

Siehe auch

• Nutzungsregeln