CA2249: Pertimbangkan untuk menggunakan String.Contains alih-alih String.IndexOf

Properti	Nilai
ID Aturan	CA2249
Judul	Pertimbangkan untuk menggunakan String.Contains alih-alih String.IndexOf
Golongan	Penggunaan
Perbaikan bersifat disruptif atau non-disruptif	Non-disruptif
Diaktifkan secara default di .NET 8	Sebagai saran

Penyebab

Aturan ini menemukan panggilan ke IndexOf tempat hasil digunakan untuk memeriksa keberadaan atau tidak adanya substring, dan menyarankan penggunaan Contains sebagai gantinya, untuk meningkatkan keterbacaan.

Deskripsi aturan

Ketika IndexOf digunakan untuk memeriksa apakah hasilnya sama dengan -1 atau lebih besar atau sama dengan 0, panggilan dapat diganti secara aman dengan Contains tanpa berdampak pada performa.

Bergantung pada kelebihan beban IndexOf yang digunakan, perbaikan yang disarankan bisa membuat argumen comparisonType ditambahkan:

Overload	Perbaikan yang disarankan
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)*

* Nilai enum StringComparison apa pun selain StringComparison.Ordinal:

• CurrentCulture
• CurrentCultureIgnoreCase
• InvariantCulture
• InvariantCultureIgnoreCase
• OrdinalIgnoreCase

Cara memperbaiki pelanggaran

Pelanggaran dapat diperbaiki secara manual, atau, dalam beberapa kasus, menggunakan Tindakan Cepat untuk memperbaiki kode di Visual Studio.

Contoh

Dua cuplikan kode berikut menunjukkan semua kemungkinan pelanggaran aturan di C# dan cara memperbaikinya:

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

Tip

Perbaikan kode tersedia untuk aturan ini di Visual Studio. Untuk menggunakannya, posisikan kursor pada pelanggaran dan tekan Ctrl+. (titik). Pilih Pertimbangkan untuk menggunakan 'string.Contains' alih-alih 'string.IndexOf' dari daftar opsi yang disajikan.

Kapan harus menekan peringatan

Aman untuk menyembunyikan pelanggaran aturan ini jika meningkatkan keterbacaan kode bukanlah masalah.

Menyembunyikan peringatan

Jika Anda hanya ingin menyembunyikan satu pelanggaran, tambahkan arahan praprosedur ke file sumber Anda untuk dinonaktifkan lalu aktifkan kembali aturannya.

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

Untuk menonaktifkan aturan untuk file, folder, atau proyek, atur tingkat keparahannya ke none dalam file konfigurasi.

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

Untuk informasi selengkapnya, lihat Cara menyembunyikan peringatan analisis kode.

Baca juga

• Aturan penggunaan