Operator kesetaraan - uji apakah dua objek sama atau tidak

  • Artikel

Operator ==(persamaan) dan != (ketidaksetaraan) memeriksa apakah operan mereka sama atau tidak. Jenis nilai sama ketika kontennya sama. Jenis referensi sama ketika dua variabel merujuk ke penyimpanan yang sama.

Operator Persamaan ==

Operator persamaan ==mengembalikantrue jika operannya sama, false jika tidak.

Persamaan jenis nilai

Operand dari tipe nilai bawaan adalah sama jika nilainya sama:

int a = 1 + 2 + 3;
int b = 6;
Console.WriteLine(a == b);  // output: True

char c1 = 'a';
char c2 = 'A';
Console.WriteLine(c1 == c2);  // output: False
Console.WriteLine(c1 == char.ToLower(c2));  // output: True

Catatan

Untuk operator ==, <, >, <=, dan >=, jika salah satu operan bukan bilangan (Double.NaN atau Single.NaN ), hasil operasinya adalah false. Itu berarti bahwa nilai NaN tidak lebih besar dari, kurang dari, atau sama dengan nilai double (ataufloat) lainnya, termasuk NaN. Untuk informasi dan contoh yang lebih lengkap, lihat artikel referensi Double.NaN dan Single.NaN.

Dua operan dari tipe enum yang sama adalah sama jika nilai yang sesuai dari tipe integral yang mendasarinya sama.

Jenis struct yang ditentukan pengguna tidak mendukung operator == secara default. Untuk mendukung operator ==, struct yang ditentukan pengguna harus membebaninya.

Operator == dan != didukung oleh tuple C#. Untuk informasi selengkapnya, lihat bagian Persamaan tuple dari artikel Jenis tuple.

Persamaan jenis referensi

Secara default, dua operan tipe referensi non-rekaman adalah sama jika merujuk ke objek yang sama:

public class ReferenceTypesEquality
{
    public class MyClass
    {
        private int id;

        public MyClass(int id) => this.id = id;
    }

    public static void Main()
    {
        var a = new MyClass(1);
        var b = new MyClass(1);
        var c = a;
        Console.WriteLine(a == b);  // output: False
        Console.WriteLine(a == c);  // output: True
    }
}

Seperti yang ditunjukkan oleh contoh ini, jenis referensi yang ditentukan pengguna mendukung == operator secara default. Namun, jenis referensi dapat membebani operator == secara berlebihan. Jika jenis referensi membebani operator ==, gunakan metode Object.ReferenceEquals untuk memeriksa apakah dua referensi jenis tersebut merujuk ke objek yang sama.

Persamaan jenis catatan

Jenis rekaman mendukung == operator dan != yang secara default memberikan semantik kesetaraan nilai. Artinya, dua operan rekaman sama ketika keduanya null atau nilai yang sesuai dari semua bidang dan properti yang diimplementasikan secara otomatis sama.

public class RecordTypesEquality
{
    public record Point(int X, int Y, string Name);
    public record TaggedNumber(int Number, List<string> Tags);

    public static void Main()
    {
        var p1 = new Point(2, 3, "A");
        var p2 = new Point(1, 3, "B");
        var p3 = new Point(2, 3, "A");

        Console.WriteLine(p1 == p2);  // output: False
        Console.WriteLine(p1 == p3);  // output: True

        var n1 = new TaggedNumber(2, new List<string>() { "A" });
        var n2 = new TaggedNumber(2, new List<string>() { "A" });
        Console.WriteLine(n1 == n2);  // output: False
    }
}

Seperti yang ditunjukkan contoh sebelumnya, untuk anggota jenis referensi non-rekaman, nilai referensi mereka dibandingkan, bukan instans yang direferensikan.

Persamaan string

Dua operan string sama jika keduanya null atau kedua instance string memiliki panjang yang sama dan memiliki karakter yang identik di setiap posisi karakter:

string s1 = "hello!";
string s2 = "HeLLo!";
Console.WriteLine(s1 == s2.ToLower());  // output: True

string s3 = "Hello!";
Console.WriteLine(s1 == s3);  // output: False

Perbandingan kesetaraan string adalah perbandingan ordinal peka huruf besar/kecil. Untuk informasi selengkapnya tentang perbandingan string, lihatlah Cara membandingkan string di C#.

Menyatakan persamaan

Dua operan delegasi dengan jenis run-time yang sama ketika keduanya adalah null atau daftar pemanggilannya memiliki panjang yang sama dan memiliki entri yang sama di setiap posisi:

Action a = () => Console.WriteLine("a");

Action b = a + a;
Action c = a + a;
Console.WriteLine(object.ReferenceEquals(b, c));  // output: False
Console.WriteLine(b == c);  // output: True

Untuk informasi selengkapnya, lihat bagian Operator delegasi persamaan dari Spesifikasi bahasa C#.

Delegasi yang dihasilkan dari evaluasi ekspresi lambda yang identik secara semantik tidak sama, seperti yang ditunjukkan contoh berikut:

Action a = () => Console.WriteLine("a");
Action b = () => Console.WriteLine("a");

Console.WriteLine(a == b);  // output: False
Console.WriteLine(a + b == a + b);  // output: True
Console.WriteLine(b + a == a + b);  // output: False

Operator tidak sama !=

Operator ketidaksetaraan != mengembalikan true jika operand-nya tidak sama, false jika tidak. Untuk operand dari jenis bawaan, ekspresi x != y menghasilkan hasil yang sama dengan ekspresi !(x == y). Untuk informasi lebih lengkap tentang persamaan jenis, lihat bagian Operator persamaan.

Contoh berikut menunjukkan penggunaan operator !=:

int a = 1 + 1 + 2 + 3;
int b = 6;
Console.WriteLine(a != b);  // output: True

string s1 = "Hello";
string s2 = "Hello";
Console.WriteLine(s1 != s2);  // output: False

object o1 = 1;
object o2 = 1;
Console.WriteLine(o1 != o2);  // output: True

Kelebihan beban operator

Sebuah jenis yang ditentukan pengguna dapat membebani operator == dan !=. Jika satu jenis membebani salah satu dari dua operator, jenis juga harus membebani yang lain.

Jenis catatan tidak dapat secara eksplisit membebani == operator dan != . Jika Anda perlu mengubah perilaku == dan != operator untuk jenis catatan T, terapkan metode IEquatable<T>.Equals dengan tanda tangan berikut:

public virtual bool Equals(T? other);

Spesifikasi bahasa C#

Untuk informasi selengkapnya, lihatlah bagian Operator relasional dan pengujian jenis dari spesifikasi bahasa C#.

Untuk informasi selengkapnya tentang persamaan jenis catatan, lihat bagian Anggota persamaan dari catatan proposal fitur rekaman.

Lihat juga