Neden C # iki nesne türünü birbiriyle karşılaştıramıyor ancak VB yapmıyor?

C # iki nesne var ve Boolean veya başka bir tür olup olmadığını bilmiyorum. Ancak bu C # karşılaştırmaya çalıştığınızda doğru cevap vermek başarısız olur. VB.NET ile aynı kodu denedim ve o yaptı!

Bir çözüm varsa kimse bunu nasıl düzeltebilir?

C #:

object a = true;
object b = true;
object c = false;
if (a == b) c = true;
MessageBox.Show(c.ToString()); //Outputs False !!

VB.NET:

Dim a As Object = True
Dim b As Object = True
Dim c As Object = False
If (a = b) Then c = True
MessageBox.Show(c.ToString()) '// Outputs True

C # 'da, ==operatör (referans tipi ifadelere uygulandığında) aşırı yüklenmedikçe bir referans eşitlik kontrolü gerçekleştirir . Boks dönüşümlerinin sonucu olan iki referansı karşılaştırıyorsunuz, bu yüzden bunlar farklı referanslar.

DÜZENLEME: Aşırı yüklenen türlerde ==, farklı davranışlar elde edebilirsiniz - ancak bu ifadelerin derleme zamanı türüne dayanır . Örneğin, aşağıdakileri stringsağlar ==(string, string):

string x = new string("foo".ToCharArray());
string y = new string("foo".ToCharArray());
Console.WriteLine(x == y); // True
Console.WriteLine((object) x == (object) y); // False

Burada ilk karşılaştırma aşırı yüklenmiş operatörü kullanmak, ikincisi ise "varsayılan" referans karşılaştırmasını kullanmaktır.

VB'de, =operatör çok daha fazla iş yapar - object.Equals(x, y)örneğin Option Comparemetinlerin karşılaştırılmasını etkileyebileceğinden , sadece kullanmaya eşdeğer değildir .

Temel olarak operatörler aynı şekilde çalışmaz ve aynı şekilde çalışma amacı taşımazlar.

Jon'un şeylerin C # tarafını açıklayan cevabına ek olarak, VB'nin yaptığı şey:

VB ile Option Strict Onkarşılaştırma, = her zaman değer eşitliğini test eder ve asla referans eşitliğini test etmez. Aslında, kodunuz geçiş yaptıktan sonra bile derlenmez Option Strict Onçünkü System.Objectbir Operator=. Her zaman bu seçeneğe sahip olmalısınız , hataları bir venüs sinek tuzağından daha etkili bir şekilde yakalar (özel durumunuzda bu gevşek davranış aslında doğru olanı yapar). ¹

Aslında, ile Option Strict Onde C #: VB C # daha sıkı davranır a == b ya bir çağrı tetikler SomeType.operator==(a, b)bu, (çağrı eşdeğerdir çağırır referans eşitlik karşılaştırma yoksa, ya da object.ReferenceEquals(a, b)).

Öte yandan VB'de karşılaştırma a = b her zaman eşitlik operatörünü çağırır. ² Referans eşitlik karşılaştırmasını kullanmak istiyorsanız, a Is b(bir kez daha aynı şekilde Object.ReferenceEquals(a, b)) kullanmanız gerekir.

¹⁾ İşte nedeni kullanarak iyi bir göstergesi Option Strict Offkötü bir fikir olduğunu: Birkaç yıl öncesine kadar .NET'in resmi yayınlanmadan önce gelen, neredeyse on yıldır kullanılan VB.NET ettik ve ben kesinlikle hiçbir fikrim Ne a = bile yapar Option Strict Off. Bir çeşit eşitlik karşılaştırması yapar, ama tam olarak ne olur ve neden, hiçbir fikir yok. Bununla birlikte, C # 'ın dynamicözelliğinden daha karmaşıktır (çünkü iyi belgelenmiş bir API'ya dayanmaktadır). MSDN şöyle diyor:

Çünkü Option Strict Oniçerir dayanıklı basım , veri kaybı ile istenmeyen tip dönüşüm, geç bağlama izin vermez engeller ve performansı artırır, kullanımı önerilir.

²⁾ Jon, eşitlik karşılaştırmasının geriye dönük uyumluluk nedeniyle daha fazla şey yaptığı bir istisna, dizeden bahsetti.

Nesne örnekleri "==" işleci ile karşılaştırılmaz. "Eşittir" yöntemini kullanmalısınız. "==" operatörü nesneleri değil referansları karşılaştırır.

Bunu dene:

public class MyObject
{
    public MyObject(String v)
    {
        Value = v;
    }
    public String Value { get; set; }
}

MyObject a = new MyObject("a");
MyObject b = new MyObject("a");
if(a==b){
    Debug.WriteLine("a reference is equal to b reference");
}else{
    Debug.WriteLine("a reference is not equal to b reference");
}
if (a.Equals(b)) {
    Debug.WriteLine("a object is equal to b object");
} else {
    Debug.WriteLine("a object is not equal to b object");
}

Sonuçlar:

a reference is not equal to b reference
a object is not equal to b object

Şimdi şunu deneyin:

public class MyObject
{
    public MyObject(String v)
    {
        Value = v;
    }
    public String Value { get; set; }

    public bool Equals(MyObject o)
    {
        return (Value.CompareTo(o.Value)==0);
    }
}
MyObject a = new MyObject("a");
MyObject b = new MyObject("a");
if(a==b){
    Debug.WriteLine("a reference is equal to b reference");
}else{
    Debug.WriteLine("a reference is not equal to b reference");
}
if (a.Equals(b)) {
    Debug.WriteLine("a object is equal to b object");
} else {
    Debug.WriteLine("a object is not equal to b object");
}

Sonuçlar:

a reference is not equal to b reference
a object is equal to b object

Sorun, C # 'daki == operatörünün , iki parametrenin derleme zamanı türüne dayalı olarak statik bir yönteme (teknik olarak belki de olmayabilir, ancak bu şekilde olabilir) bir çağrı olmasıdır . Bu nesnelerin gerçek çalışma zamanı türlerinin ne olduğu önemli değildir.

Bu derleme zamanı türüne göre derleyici hangi uygulamanın operator ==kullanılacağını belirler. Varsayılan objectuygulamayı kullanabilir, dil tarafından sağlanan sayısal aşırı yüklemelerden birini kullanabilir veya kullanıcı tanımlı bir uygulama olabilir.

Bu, VB'nin derleme zamanında uygulamayı belirlememesi nedeniyle VB'den farklıdır. Çalışma zamanına kadar bekler ve ==operatörün hangi uygulamasını kullanması gerektiğini belirlemek için verilen iki parametreyi inceler .

Kodunuz boole değerleri içeriyor, ancak bunlar türdeki değişkenlerde object. Çünkü değişken tiptedir object, C # derleyicisi kullanımı objectuygulanmasını ==karşılaştırır, referans değil, Nesne örnekleri. Boole değerleri kutular olduğundan, değerleri aynı olmasına rağmen aynı referansa sahip değildirler.

VB kodu, değişkenin ne tür olduğu umurumda değildir. Çalışma zamanına kadar bekler ve sonra iki değişkeni denetler, aslında her iki boolean türünde olduklarını görür ve böylece boolean ==işleç uygulamasını kullanır . Bu uygulama, referanslarını değil, booleanların değerlerini karşılaştırır (ve bu operatörü çağırmadan önce boolean'lar kutudan çıkarılır, bu nedenle referans karşılaştırması artık mantıklı değildir). Boolean'ların değerleri aynı olduğu için true değerini döndürür.