Не может ли оператор == быть применен к универсальным типам в C #?

Согласно документации ==оператора в MSDN ,

Для предопределенных типов значений оператор равенства (==) возвращает true, если значения его операндов равны, в противном случае - false. Для ссылочных типов, отличных от string, == возвращает true, если два его операнда ссылаются на один и тот же объект. Для типа строки == сравнивает значения строк. Пользовательские типы значений могут перегружать оператор == (см. Оператор). То же самое можно сказать и о пользовательских ссылочных типах, хотя по умолчанию == ведет себя так, как описано выше, как для предопределенных, так и для пользовательских ссылочных типов.

Так почему этот фрагмент кода не компилируется?

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

Я получаю сообщение об ошибке. Оператор '==' не может быть применен к операндам типа 'T' и 'T' . Интересно почему, поскольку, насколько я понимаю, ==оператор предопределен для всех типов?

Редактировать: Спасибо всем. Сначала я не заметил, что утверждение касается только ссылочных типов. Я также подумал, что побитовое сравнение предоставляется для всех типов значений, что, как я теперь знаю, не является правильным.

Но если я использую ссылочный тип, будет ли ==оператор использовать предопределенное сравнение ссылок, или он будет использовать перегруженную версию оператора, если тип определен?

Редактировать 2: методом проб и ошибок мы узнали, что ==оператор будет использовать предопределенное эталонное сравнение при использовании неограниченного универсального типа. Фактически, компилятор будет использовать лучший метод, который он может найти для аргумента ограниченного типа, но не будет искать дальше. Например, приведенный ниже код будет всегда печататься true, даже когда 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); } }

«... по умолчанию == ведет себя так, как описано выше как для предопределенных, так и для пользовательских типов ссылок.»

Тип T не обязательно является ссылочным типом, поэтому компилятор не может сделать это предположение.

Тем не менее, это скомпилируется, потому что это более явно:

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

Ответьте на дополнительный вопрос: «Но если я использую ссылочный тип, будет ли оператор == использовать предопределенное сравнение ссылок или будет перегруженная версия оператора, если тип определен?»

Я бы подумал, что == на Generics будет использовать перегруженную версию, но следующий тест демонстрирует обратное. Интересно ... Я хотел бы знать, почему! Если кто-то знает, пожалуйста, поделитесь.

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

Вывод

Встроенный: перегружен == называется

Общий:

Нажмите любую клавишу для продолжения . , ,

Follow Up 2

Я хочу отметить, что изменение моего метода сравнения на

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

вызывает перегруженный оператор ==. Я предполагаю, что без указания типа (как где ) компилятор не может сделать вывод, что он должен использовать перегруженный оператор ... хотя я думаю, что у него будет достаточно информации, чтобы принять это решение, даже не указав тип.

Как уже говорили другие, он будет работать только тогда, когда T ограничен ссылочным типом. Без каких-либо ограничений вы можете сравнивать со значением NULL, но только со значением NULL - и это сравнение всегда будет ложным для типов значений, не допускающих значения NULL.

Вместо вызова Equals лучше использовать IComparer<T>- и если у вас нет больше информации, EqualityComparer<T>.Defaultэто хороший выбор:

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

Помимо всего прочего, это позволяет избежать бокса / кастинга.

В общем, EqualityComparer<T>.Default.Equalsследует выполнять работу с чем-либо, что реализует IEquatable<T>или имеет разумную Equalsреализацию.

Если, однако, ==и Equalsпо какой-то причине реализованы по-другому, то моя работа над универсальными операторами должна быть полезной; поддерживает операторские версии (среди прочих):

• Равен (значение T1, значение T2)
• NotEqual (значение T1, значение T2)
• GreaterThan (значение T1, значение T2)
• LessThan (значение T1, значение T2)
• GreaterThanOrEqual (значение T1, значение T2)
• LessThanOrEqual (значение T1, значение T2)

Так много ответов, и ни один не объясняет ПОЧЕМУ? (который явно спросил Джованни) ...

Обобщения .NET не действуют как шаблоны C ++. В шаблонах C ++ разрешение перегрузки происходит после того, как фактические параметры шаблона известны.

В универсальных .NET (в том числе C #) разрешение перегрузки происходит без знания фактических универсальных параметров. Единственная информация, которую компилятор может использовать для выбора вызываемой функции, связана с ограничениями типов общих параметров.

Компиляция не может знать, что T не может быть структурой (типом значения). Так что вы должны сказать, что это может быть только ссылочный тип, я думаю:

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

Это потому, что если T может быть типом значения, могут быть случаи, когда x == yон будет плохо сформирован - в тех случаях, когда для типа не определен оператор ==. То же самое произойдет для этого, что более очевидно:

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

Это тоже не помогает, потому что вы можете передать тип T, у которого не будет функции foo. C # заставляет вас убедиться, что все возможные типы всегда имеют функцию foo. Это делается с помощью предложения where.

Похоже, что без ограничения класса:

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

Следует понимать, что в то время как classограничение Equalsв ==операторе наследуется от Object.Equals, а у структуры переопределяется ValueType.Equals.

Обратите внимание, что:

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

также выдает ту же ошибку компилятора.

Пока я не понимаю, почему компилятор отвергает сравнение операторов равенства типов значений. Я точно знаю, что это работает:

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

Ну, в моем случае я хотел провести модульное тестирование оператора равенства. Мне нужно было вызывать код под операторами равенства без явной установки универсального типа. Советы для EqualityComparerне были полезны как EqualityComparerвызываемый Equalsметод, но не оператор равенства.

Вот как у меня это работает с универсальными типами путем построения LINQ. Он называет правильный код ==и !=операторов:

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

Существует запись MSDN Connect для этого здесь

Ответ Алекса Тернера начинается с:

К сожалению, такое поведение разработано специально, и не существует простого решения, позволяющего использовать == с параметрами типа, которые могут содержать типы значений.

Если вы хотите убедиться, что операторы вашего пользовательского типа вызываются, вы можете сделать это с помощью отражения. Просто получите тип, используя ваш универсальный параметр, и получите MethodInfo для нужного оператора (например, op_Equality, op_Inequality, op_LessThan ...).

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

Затем выполните оператор, используя метод Invoke для MethodInfo, и передайте объекты в качестве параметров.

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

Это вызовет ваш перегруженный оператор, а не тот, который определен ограничениями, примененными к универсальному параметру. Может быть непрактичным, но может пригодиться для модульного тестирования ваших операторов при использовании базового базового класса, который содержит пару тестов.

Я написал следующую функцию, глядя на последний MSDN. Он может легко сравнить два объекта xи 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; }

Вышесказанное будет работать, потому что == позаботится в случае пользовательских типов ссылок.
В случае типов значений == может быть переопределено. В этом случае "! =" Также должно быть определено.

Я думаю, что это может быть причиной, это запрещает общее сравнение, используя "==".

.Equals()Работает для меня в то время как TKeyэто общий тип.

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


    // ...
}