Operatör ==, C # içindeki genel türlere uygulanamaz mı?

Belgelerine göre ==operatör MSDN ,

Önceden tanımlanmış değer türleri için, işlenenlerinin değerleri eşitse eşitlik operatörü (==) true değerini, aksi takdirde false değerini döndürür. Dize dışındaki başvuru türleri için, iki işleneni aynı nesneye başvuruyorsa == true değerini döndürür. Dize türü için ==, dizelerin değerlerini karşılaştırır. Kullanıcı tanımlı değer türleri == operatörünü aşırı yükleyebilir (operatöre bakın). Varsayılan olarak == yukarıda tanımlanmış ve kullanıcı tanımlı referans türleri için yukarıda açıklandığı gibi davranmasına rağmen , kullanıcı tanımlı referans türleri de kullanılabilir.

Peki bu kod pasajı neden derlenemiyor?

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

'==' İşleci 'T' ve 'T' tipi işlenenlere uygulanamıyor hatasını alıyorum . Acaba neden anladığım kadarıyla ==operatör tüm tipler için önceden tanımlanmış?

Düzenleme: Herkese teşekkürler. İlk başta ifadenin sadece referans türleriyle ilgili olduğunu fark etmedim. Ayrıca, artık doğru olmadığını bildiğim tüm değer türleri için bit-bit karşılaştırmasının sağlandığını düşündüm .

Ancak, bir referans türü ==kullanmam durumunda , operatör önceden tanımlanmış referans karşılaştırmasını kullanır mı yoksa bir tür tanımlıysa, operatörün aşırı yüklenmiş sürümünü kullanır mı?

Düzenleme 2: Deneme yanılma yoluyla, ==operatörün sınırsız bir genel tip kullanırken önceden tanımlanmış referans karşılaştırmasını kullanacağını öğrendik . Aslında, derleyici kısıtlı tür argümanı için bulabileceği en iyi yöntemi kullanacaktır, ancak daha fazla bakmayacaktır. Örneğin, aşağıdaki kod çağrılsa truebile her zaman yazdırılır Test.test<B>(new B(), new B()):

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

"... varsayılan olarak ==, hem önceden tanımlanmış hem de kullanıcı tanımlı referans türleri için yukarıda açıklandığı şekilde davranır."

T tipi mutlaka bir referans türü değildir, bu nedenle derleyici bu varsayımı yapamaz.

Ancak, bu daha açık olduğu için derlenecektir:

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

"Ancak, bir referans türü kullanmam durumunda == operatörü önceden tanımlanmış referans karşılaştırmasını kullanır mı yoksa bir tür tanımlıysa operatörün aşırı yüklenmiş sürümünü kullanır mı?"

Ben Generics üzerinde == aşırı yüklenmiş sürümünü kullanmak düşünürdüm, ama aşağıdaki test aksi gösterir. İlginç ... Nedenini bilmek isterdim! Birisi bilirse lütfen paylaşın.

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

Çıktı

Satır içi: Aşırı yüklenmiş == çağrılan

jenerik:

Devam etmek için herhangi bir tuşa basın . . .

Takip 2

Karşılaştırma yöntemimi değiştirmenin

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

aşırı yüklenmiş == operatörünün çağrılmasına neden olur. Tipini ( nerede ) belirtmeden tahmin ediyorum , derleyici aşırı yüklenmiş operatörü kullanması gerektiğini çıkaramaz ... gerçi tip belirtmeden bile karar vermek için yeterli bilgiye sahip olacağını düşünürdüm.

Diğerlerinin söylediği gibi, sadece T bir referans tipi olarak kısıtlandığında çalışır. Herhangi bir kısıtlama olmadan, null, ancak null ile karşılaştırabilirsiniz; bu karşılaştırma, null değeri olmayan değer türleri için her zaman yanlış olur.

Eşittir demek yerine IComparer<T>- kullanmak daha iyidir ve daha fazla bilginiz yoksa EqualityComparer<T>.Defaultiyi bir seçimdir:

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

Başka bir şey dışında, bu boks / dökümden kaçınır.

Genel olarak, EqualityComparer<T>.Default.Equalsişi uygulayan IEquatable<T>veya mantıklı bir Equalsuygulaması olan herhangi bir şeyle yapmalıdır .

Bununla birlikte, ==ve Equalsherhangi bir nedenle farklı şekilde uygulanırsa, genel operatörler üzerindeki çalışmamın yararlı olması gerekir; (diğerleri arasında) operatör sürümlerini destekler :

• Eşit (T değeri1, T değeri2)
• Eşit Değil (T değeri1, T değeri2)
• GreaterThan (T değeri1, T değeri2)
• LessThan (T değeri1, T değeri2)
• GreaterThanOrEqual (T değeri1, T değeri2)
• LessThanOrEqual (T değeri1, T değeri2)

Çok fazla cevap var, tek bir cevap neden değil? (Giovanni açıkça sordu) ...

.NET jenerikleri C ++ şablonları gibi davranmaz. C ++ şablonlarında, gerçek şablon parametreleri bilindikten sonra aşırı yük çözünürlüğü oluşur.

.NET jeneriklerinde (C # dahil), aşırı yük çözünürlüğü gerçek genel parametreleri bilmeden oluşur. Derleyicinin çağrılacak işlevi seçmek için kullanabileceği tek bilgi, genel parametrelerdeki tür kısıtlamalarından gelir.

Derleme, T'nin bir yapı (değer türü) olamayacağını bilemez. Bu yüzden sadece referans türü olduğunu düşünüyorum söylemek gerekir:

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

Çünkü T bir değer türü olabiliyorsa, x == yhastalığın oluşturulacağı durumlar olabilir - bir türün operatörü == tanımlı değilse. Aynı şey daha açık olan için de olacak:

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

Bu da başarısız olur, çünkü foo işlevi olmayan bir T tipini geçebilirsiniz. C # sizi tüm olası türlerin her zaman foo işlevine sahip olduğundan emin olmaya zorlar. Bu nerede fıkra tarafından yapılır.

Sınıf kısıtı olmadan:

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

Bir fark gerekirken bu classkısıtlı Equalsiçinde ==gelen operatör INHERITS Object.Equalsbir yapı bindirilmesi o süre ValueType.Equals.

Bunu not et:

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

aynı derleyici hatasını verir.

Henüz bir değer tipi eşitlik operatörü karşılaştırmasının neden derleyici tarafından reddedildiğini anlamıyorum. Gerçi bunun bir işe yaradığını biliyorum:

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

Benim durumumda eşitlik operatörünün birim testini yapmak istedim. Ben açıkça genel türü ayarlamadan eşitlik operatörleri altında kodu çağırmak gerekiyordu. İçin önerilerde EqualityComparergibi yararlı değil EqualityComparerdenilen Equalsyöntemle ancak eşitlik operatörü.

İşte a LINQ. Operatörler ==ve !=operatörler için doğru kodu çağırır :

/// <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);
}

Burada bunun için bir MSDN Connect girişi var

Alex Turner'ın yanıtı şununla başlar:

Ne yazık ki, bu davranış tasarım gereğidir ve == değer türlerini içerebilecek tür parametreleriyle kullanımını etkinleştirmek için kolay bir çözüm yoktur.

Özel türünüzün operatörlerinin çağrıldığından emin olmak istiyorsanız, bunu yansıma yoluyla yapabilirsiniz. Sadece genel parametrenizi kullanarak yazın ve istenen operatör için MethodInfo'yu alın (örn. Op_Equality, op_Inequality, op_LessThan ...).

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

Ardından, MethodInfo's Invoke yöntemini kullanarak operatörü yürütün ve nesneleri parametre olarak iletin.

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

Bu, aşırı yük operatörünüzü çağırır, genel parametreye uygulanan kısıtlamalar tarafından tanımlanan operatörü çağırmaz. Pratik olmayabilir, ancak birkaç test içeren genel bir temel sınıf kullanırken operatörlerinizi birim test etmek için kullanışlı olabilir.

En son msdn bakarak aşağıdaki işlevi yazdı. İki nesneyi kolayca karşılaştırabilir xve 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; }

Yukarıdakiler işe yarayacaktır çünkü kullanıcı tanımlı referans türlerinde == dikkate alınır.
Değer türleri durumunda, == geçersiz kılınabilir. Bu durumda, "! =" De tanımlanmalıdır.

Bunun nedeni olabileceğini düşünüyorum, "==" kullanarak genel karşılaştırmaya izin vermiyor.

.Equals()Ederken benim için çalışan TKeybir genel türüdür.

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


    // ...
}