Tidak bisakah operator == diterapkan pada tipe umum dalam C #?

Menurut dokumentasi ==operator di MSDN ,

Untuk tipe nilai yang telah ditentukan, operator persamaan (==) mengembalikan true jika nilai operandnya sama, salah jika tidak. Untuk tipe referensi selain string, == mengembalikan true jika kedua operandnya merujuk ke objek yang sama. Untuk tipe string, == membandingkan nilai string. Jenis nilai yang ditentukan pengguna dapat membebani operator == (lihat operator). Demikian juga tipe referensi yang ditentukan pengguna, meskipun secara default == berperilaku seperti yang dijelaskan di atas untuk tipe referensi yang ditentukan sebelumnya dan yang ditentukan pengguna.

Jadi mengapa cuplikan kode ini gagal dikompilasi?

bool Compare<T>(T x, T y) { return x == y; }

Saya mendapatkan kesalahan Operator '==' tidak dapat diterapkan ke operan tipe 'T' dan 'T' . Saya bertanya-tanya mengapa, karena sejauh yang saya mengerti ==operator sudah ditentukan untuk semua jenis?

Sunting: Terima kasih, semuanya. Awalnya saya tidak memperhatikan bahwa pernyataan itu hanya tentang tipe referensi. Saya juga berpikir bahwa perbandingan sedikit demi sedikit disediakan untuk semua tipe nilai, yang sekarang saya tahu tidak benar.

Tetapi, jika saya menggunakan tipe referensi, apakah ==operator akan menggunakan perbandingan referensi yang sudah ditentukan sebelumnya, atau akankah menggunakan versi overload dari operator jika suatu tipe didefinisikan?

Sunting 2: Melalui percobaan dan kesalahan, kami mengetahui bahwa ==operator akan menggunakan perbandingan referensi yang telah ditentukan saat menggunakan jenis generik yang tidak dibatasi. Sebenarnya, kompiler akan menggunakan metode terbaik yang dapat ditemukan untuk argumen tipe terbatas, tetapi tidak akan mencari lagi. Misalnya, kode di bawah ini akan selalu dicetak true, bahkan ketika Test.test<B>(new B(), new B())dipanggil:

class A { public static bool operator==(A x, A y) { return true; } }
class B : A { public static bool operator==(B x, B y) { return false; } }
class Test { void test<T>(T a, T b) where T : A { Console.WriteLine(a == b); } }

"... secara default == berperilaku seperti dijelaskan di atas untuk tipe referensi yang ditentukan sebelumnya dan yang ditentukan pengguna."

Tipe T belum tentu merupakan tipe referensi, jadi kompiler tidak dapat membuat asumsi itu.

Namun, ini akan dikompilasi karena lebih eksplisit:

    bool Compare<T>(T x, T y) where T : class
    {
        return x == y;
    }

Tindak lanjuti pertanyaan tambahan, "Tapi, kalau-kalau saya menggunakan tipe referensi, apakah operator == akan menggunakan perbandingan referensi yang telah ditentukan, atau akankah ia menggunakan versi overload dari operator jika suatu tipe mendefinisikannya?"

Saya akan berpikir bahwa == pada Generik akan menggunakan versi overload, tetapi tes berikut menunjukkan sebaliknya. Menarik ... Saya ingin tahu kenapa! Jika ada yang tahu, silakan berbagi.

namespace TestProject
{
 class Program
 {
    static void Main(string[] args)
    {
        Test a = new Test();
        Test b = new Test();

        Console.WriteLine("Inline:");
        bool x = a == b;
        Console.WriteLine("Generic:");
        Compare<Test>(a, b);

    }


    static bool Compare<T>(T x, T y) where T : class
    {
        return x == y;
    }
 }

 class Test
 {
    public static bool operator ==(Test a, Test b)
    {
        Console.WriteLine("Overloaded == called");
        return a.Equals(b);
    }

    public static bool operator !=(Test a, Test b)
    {
        Console.WriteLine("Overloaded != called");
        return a.Equals(b);
    }
  }
}

Keluaran

Inline: Kelebihan == dipanggil

Umum:

Tekan tombol apa saja untuk melanjutkan . . .

Tindak Lanjut 2

Saya ingin menunjukkan bahwa mengubah metode perbandingan ke

    static bool Compare<T>(T x, T y) where T : Test
    {
        return x == y;
    }

menyebabkan operator == kelebihan beban dipanggil. Saya kira tanpa menentukan jenisnya (sebagai mana ), kompiler tidak dapat menyimpulkan bahwa ia harus menggunakan operator yang kelebihan beban ... meskipun saya pikir itu akan memiliki informasi yang cukup untuk membuat keputusan itu bahkan tanpa menentukan jenisnya.

Seperti yang dikatakan orang lain, ini hanya akan berfungsi ketika T dibatasi menjadi tipe referensi. Tanpa kendala apa pun, Anda dapat membandingkan dengan nol, tetapi hanya nol - dan perbandingan itu akan selalu salah untuk tipe nilai yang tidak dapat dibatalkan.

Alih-alih memanggil Equals, lebih baik menggunakan IComparer<T>- dan jika Anda tidak memiliki informasi lagi, EqualityComparer<T>.Defaultadalah pilihan yang baik:

public bool Compare<T>(T x, T y)
{
    return EqualityComparer<T>.Default.Equals(x, y);
}

Selain dari hal lain, ini menghindari tinju / casting.

Secara umum, EqualityComparer<T>.Default.Equalsharus melakukan pekerjaan dengan apa pun yang mengimplementasikan IEquatable<T>, atau yang memiliki Equalsimplementasi yang masuk akal .

Namun, jika ==dan Equalsdiimplementasikan secara berbeda karena alasan tertentu, maka pekerjaan saya pada operator generik akan berguna; mendukung versi operator (antara lain):

• Equal (Nilai T1, Nilai T2)
• NotEqual (T value1, T value2)
• GreaterThan (Nilai T1, Nilai T2)
• LessThan (Nilai T1, Nilai T2)
• GreaterThanOrEqual (Nilai T1, Nilai T2)
• LessThanOrEqual (Nilai T1, Nilai T2)

Begitu banyak jawaban, dan tidak satu pun yang menjelaskan MENGAPA? (yang diminta secara eksplisit oleh Giovanni) ...

.NET generics tidak bertindak seperti template C ++. Di template C ++, resolusi kelebihan terjadi setelah parameter template aktual diketahui.

Dalam .NET generics (termasuk C #), resolusi kelebihan terjadi tanpa mengetahui parameter generik yang sebenarnya. Satu-satunya informasi yang dapat digunakan kompilator untuk memilih fungsi untuk memanggil berasal dari batasan tipe pada parameter generik.

Kompilasi tidak dapat mengetahui T tidak dapat berupa struct (tipe nilai). Jadi Anda harus mengatakan itu hanya bisa dari jenis referensi, saya pikir:

bool Compare<T>(T x, T y) where T : class { return x == y; }

Itu karena jika T bisa menjadi tipe nilai, mungkin ada kasus di mana x == yakan terbentuk buruk - dalam kasus ketika tipe tidak memiliki operator == didefinisikan. Hal yang sama akan terjadi untuk ini yang lebih jelas:

void CallFoo<T>(T x) { x.foo(); }

Itu gagal juga, karena Anda bisa melewati tipe T yang tidak akan memiliki fungsi foo. C # memaksa Anda untuk memastikan semua tipe yang mungkin selalu memiliki fungsi foo. Itu dilakukan oleh klausa mana.

Tampaknya tanpa batasan kelas:

bool Compare<T> (T x, T y) where T: class
{
    return x == y;
}

Orang harus menyadari bahwa sementara classdibatasi Equalsdalam ==operator mewarisi dari Object.Equals, sedangkan yang menimpa struct ValueType.Equals.

Perhatikan bahwa:

bool Compare<T> (T x, T y) where T: struct
{
    return x == y;
}

juga memberikan kesalahan kompiler yang sama.

Sampai sekarang saya tidak mengerti mengapa memiliki perbandingan operator kesetaraan tipe nilai ditolak oleh kompiler. Saya tahu pasti, bahwa ini bekerja:

bool Compare<T> (T x, T y)
{
    return x.Equals(y);
}

Baik dalam kasus saya, saya ingin menguji unit operator kesetaraan. Saya perlu memanggil kode di bawah operator kesetaraan tanpa secara eksplisit menetapkan jenis generik. Saran untuk EqualityComparertidak membantu EqualityComparerdisebut Equalsmetode tetapi bukan operator kesetaraan.

Berikut adalah cara kerja ini dengan tipe generik dengan membangun a LINQ. Itu memanggil kode yang tepat untuk ==dan !=operator:

/// <summary>
/// Gets the result of "a == b"
/// </summary>
public bool GetEqualityOperatorResult<T>(T a, T b)
{
    // declare the parameters
    var paramA = Expression.Parameter(typeof(T), nameof(a));
    var paramB = Expression.Parameter(typeof(T), nameof(b));
    // get equality expression for the parameters
    var body = Expression.Equal(paramA, paramB);
    // compile it
    var invokeEqualityOperator = Expression.Lambda<Func<T, T, bool>>(body, paramA, paramB).Compile();
    // call it
    return invokeEqualityOperator(a, b);
}

/// <summary>
/// Gets the result of "a =! b"
/// </summary>
public bool GetInequalityOperatorResult<T>(T a, T b)
{
    // declare the parameters
    var paramA = Expression.Parameter(typeof(T), nameof(a));
    var paramB = Expression.Parameter(typeof(T), nameof(b));
    // get equality expression for the parameters
    var body = Expression.NotEqual(paramA, paramB);
    // compile it
    var invokeInequalityOperator = Expression.Lambda<Func<T, T, bool>>(body, paramA, paramB).Compile();
    // call it
    return invokeInequalityOperator(a, b);
}

Ada entri MSDN Connect untuk ini di sini

Balasan Alex Turner dimulai dengan:

Sayangnya, perilaku ini dirancang dan tidak ada solusi mudah untuk memungkinkan penggunaan == dengan parameter tipe yang mungkin berisi tipe nilai.

Jika Anda ingin memastikan operator jenis kustom Anda dipanggil, Anda dapat melakukannya melalui refleksi. Dapatkan saja tipe menggunakan parameter generik Anda dan ambil MethodInfo untuk operator yang diinginkan (mis. Op_Equality, op_Inequality, op_LessThan ...).

var methodInfo = typeof (T).GetMethod("op_Equality", 
                             BindingFlags.Static | BindingFlags.Public);    

Kemudian jalankan operator menggunakan metode Invoke MethodInfo's dan meneruskan objek sebagai parameter.

var result = (bool) methodInfo.Invoke(null, new object[] { object1, object2});

Ini akan memanggil operator kelebihan beban Anda dan bukan yang ditentukan oleh kendala yang diterapkan pada parameter generik. Mungkin tidak praktis, tetapi bisa berguna untuk unit menguji operator Anda saat menggunakan kelas dasar generik yang berisi beberapa tes.

Saya menulis fungsi berikut melihat msdn terbaru. Itu dapat dengan mudah membandingkan dua objek xdan y:

static bool IsLessThan(T x, T y) 
{
    return ((IComparable)(x)).CompareTo(y) <= 0;
}

bool Compare(T x, T y) where T : class { return x == y; }

Hal di atas akan berfungsi karena == dirawat jika ada jenis referensi yang ditentukan pengguna.
Dalam hal tipe nilai, == dapat diganti. Dalam hal ini, "! =" Juga harus didefinisikan.

Saya pikir itu bisa menjadi alasannya, ia tidak mengizinkan perbandingan umum menggunakan "==".

The .Equals()bekerja untuk saya sementara TKeyadalah jenis generik.

public virtual TOutputDto GetOne(TKey id)
{
    var entity =
        _unitOfWork.BaseRepository
            .FindByCondition(x => 
                !x.IsDelete && 
                x.Id.Equals(id))
            .SingleOrDefault();


    // ...
}