Почему 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 # ==оператор (применительно к выражениям ссылочного типа) выполняет проверку равенства ссылок, если только он не перегружен . Вы сравниваете две ссылки, которые являются результатом преобразования в бокс, так что это разные ссылки.

РЕДАКТИРОВАТЬ: С типами, которые перегружают ==, вы можете получить различное поведение - но это основано на типе выражений во время компиляции . Например, 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 OnVB ведет себя еще строже, чем в 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 не имеет значения, какой тип переменной. Он ждет до времени выполнения, а затем проверяет две переменные, видит, что они на самом деле имеют тип boolean, и поэтому использует реализацию логического ==оператора. Эта реализация сравнивает значения логических значений, а не их ссылок (и логические значения будут распакованы перед вызовом этого оператора, поэтому сравнение ссылок даже не имеет смысла). Поскольку значения логических значений совпадают, возвращается значение true.