Чому C # не вдається порівняти два типи об'єктів один з одним, але VB не робить?

У мене є два об'єкти в C # і не знаю, булева чи будь-який інший тип. Однак, коли я намагаюся порівняти ці C # не вдається дати правильну відповідь. Я спробував той самий код з VB.NET, і це вдалося!

Хтось може сказати мені, як це виправити, якщо є рішення?

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 #, ==оператор (якщо застосовується до виразів опорного типу) здійснює перевірку рівності еталонних даних, якщо він не перевантажений . Ви порівнюєте дві посилання, які є результатом перетворень боксу, тому це окремі посилання.

EDIT: За типи, які перевантажують ==, ви можете отримувати різну поведінку, але це базується на типі виразів часу компіляції . Наприклад, stringнадає ==(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

Тут перше порівняння використовує перевантажений оператор, а друге використовує порівняльне посилання "за замовчуванням".

У VB =оператор робить набагато більше роботи - це навіть не просто еквівалент використання object.Equals(x, y), оскільки такі речі Option Compareможуть впливати на порівняння тексту.

По суті, оператори не працюють однаково і не мають наміру працювати однаково.

Окрім відповіді Джона, яка пояснює C # сторону речей, ось що робить VB:

У VB з Option Strict On, порівняння за допомогою = завжди тестів на рівність значення і ніколи на еталонну рівність. Насправді ваш код навіть не компілюється, коли ви переходитеOption Strict On оскільки System.Objectне визначає Operator=. У вас завжди має бути увімкнено цей параметр, він виявляє помилок ефективніше, ніж венерина мухоловка (хоча у вашому конкретному випадку ця млява поведінка насправді робить правильно). ¹

Насправді, з Option Strict On, VB поводиться навіть суворіше, ніж C #: У C #,a == b або ініціює виклик, SomeType.operator==(a, b)або, якщо цього не існує, викликає порівняння еталонної рівності (що еквівалентно виклику object.ReferenceEquals(a, b)).

З іншого боку, VB порівняння a = b завжди посилається на оператора рівності.² Якщо ви хочете використовувати порівняльне порівняння порівняння, вам доведеться використовувати a Is b(що, знову ж таки, те саме Object.ReferenceEquals(a, b)).

¹⁾ Ось хороша вказівка, чому використання Option Strict Off- це погана ідея: я використовував VB.NET майже десятиліття, починаючи з офіційного релізу .NET до декількох років тому, і я абсолютно не знаю, що a = bз цимOption Strict Off . Це робить якесь порівняння рівності, але що саме відбувається і чому, поняття немає. Хоча це складніше, ніж dynamicфункція C # (адже це спирається на добре задокументований API). Ось що говорить MSDN:

Тому що Option Strict On забезпечує сильне введення тексту , запобігає перетворенню ненавмисних типів із втратою даних, вимикає запізніле прив'язування та покращує продуктивність, настійно рекомендується його використання.

²⁾ Джон згадав один виняток, рядки, де порівняння рівності робить ще деякі речі з міркувань зворотної сумісності.

Екземпляри об'єктів не порівнюються з оператором "==". Вам слід використовувати метод "дорівнює". З оператором "==" порівнюють посилання, а не об'єкти.

Спробуйте це:

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

Результати:

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

Тепер спробуйте це:

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

Результати:

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

Проблема полягає в тому, що оператор == у C # - це виклик статичного методу (ну, можливо, технічно, але він може бути хоч як такий) на основі типу часу компіляції двох параметрів. Які фактичні типи виконання цих об’єктів не мають значення.

На основі цього часу компіляції компілятор визначатиме, яку реалізацію operator ==використовувати. Може використовуватись за замовчуваннямobject реалізацію , він може використовувати одне з числових перевантажень, що надаються мовою, або це може бути визначена користувачем реалізація.

Це відрізняється від VB тим, що VB не визначає реалізацію під час компіляції. Він чекає часу виконання та перевіряє два параметри, які йому задані, щоб визначити, яку реалізацію ==оператора він повинен використовувати.

Ваш код містить булеві значення, але вони знаходяться в змінних типу object. Тому що змінна має тип object, компілятор C # використовує objectреалізацію ==, яка порівнює посилання , а не об'єктні екземпляри. Оскільки булеві значення є полями, вони не мають однакового посилання, хоча їх значення однакові.

Код VB не має значення, який тип змінної. Він чекає, поки час виконання, а потім перевіряє дві змінні, бачить, що вони насправді є обома булевими типами, і тому використовує булевий== оператора. Ця реалізація порівнює значення булевих, а не їх посилань (і булеві будуть виводитись з коду до виклику цього оператора, тому порівняння посилань навіть більше не має сенсу). Оскільки значення булевих значень однакові, воно повертає істинні.