演算子==はC＃のジェネリック型に適用できませんか？

MSDNの==オペレーターのドキュメントによると、

定義済みの値タイプの場合、等価演算子（==）は、そのオペランドの値が等しい場合はtrueを返し、それ以外の場合はfalseを返します。文字列以外の参照型の場合、2つのオペランドが同じオブジェクトを参照している場合、==は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);
    }
  }
}

出力

インライン：オーバーロード==呼び出されました

一般：

何かキーを押すと続行します 。。。

フォローアップ2

比較方法を次のように変更することを指摘しておきます

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

オーバーロードされた==演算子が呼び出されます。タイプを（whereとして）指定しないと、コンパイラーはオーバーロードされた演算子を使用する必要があると推測できません...タイプを指定しなくても、その決定を行うのに十分な情報があると思います。

他の人が言ったように、Tが参照型になるように制約されている場合にのみ機能します。制約がなければ、nullと比較できますが、nullのみです。null以外の値の型の場合、その比較は常にfalseになります。

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、何らかの理由で別々に実装され、その後、上の私の仕事の一般的な演算子は有用であろう。それは（とりわけ）のオペレーターバージョンをサポートしています：

• Equal（T value1、T value2）
• NotEqual（T値1、T値2）
• GreaterThan（T値1、T値2）
• LessThan（T値1、T値2）
• GreaterThanOrEqual（T value1、T value2）
• LessThanOrEqual（T値1、T値2）

多くの答えがあり、1つではないのでなぜその理由が説明されますか？（ジョヴァンニが明示的に尋ねた）...

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

関数fooを持たないT型を渡すことができるため、これも失敗します。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です。==and !=演算子の適切なコードを呼び出します。

/// <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エントリがあります。

Alex Turnerの返答は次のように始まります。

残念ながら、この動作は仕様によるものであり、値の型を含む可能性のある型パラメーターで==を使用できるようにする簡単な解決策はありません。

カスタムタイプの演算子が呼び出されることを確認したい場合は、リフレクションを介して呼び出すことができます。ジェネリックパラメーターを使用して型を取得し、目的の演算子（たとえば、op_Equality、op_Inequality、op_LessThan ...）のMethodInfoを取得するだけです。

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

次に、MethodInfoのInvokeメソッドを使用して演算子を実行し、オブジェクトをパラメーターとして渡します。

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

これにより、オーバーロードされた演算子が呼び出され、ジェネリックパラメーターに適用された制約によって定義された演算子は呼び出されません。実用的ではないかもしれませんが、いくつかのテストを含むジェネリック基本クラスを使用する場合に、オペレーターのユニットテストに役立ちます。

最新のmsdnを見ながら以下の関数を書いた。2つのオブジェクト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();


    // ...
}