ไม่สามารถใช้โอเปอเรเตอร์ == กับประเภททั่วไปใน C # ได้หรือไม่

ตามเอกสารของ==ผู้ประกอบการในMSDN ,

สำหรับประเภทค่าที่กำหนดไว้ล่วงหน้าตัวดำเนินการความเท่าเทียมกัน (==) จะส่งกลับค่าจริงถ้าค่าของตัวถูกดำเนินการเท่ากันเท็จมิฉะนั้น สำหรับชนิดการอ้างอิงอื่นที่ไม่ใช่สตริง == จะส่งกลับค่าจริงถ้าตัวถูกดำเนินการทั้งสองอ้างถึงวัตถุเดียวกัน สำหรับประเภทสตริง == เปรียบเทียบค่าของสตริง ประเภทค่าที่ผู้ใช้กำหนดสามารถโอเวอร์โหลดตัวดำเนินการ == (ดูโอเปอเรเตอร์) ดังนั้นประเภทการอ้างอิงที่ผู้ใช้กำหนดสามารถทำได้ โดยค่าเริ่มต้น == จะทำงานตามที่อธิบายไว้ข้างต้นสำหรับทั้งประเภทการอ้างอิงที่กำหนดไว้ล่วงหน้าและที่ผู้ใช้กำหนด

เหตุใดข้อมูลโค้ดนี้จึงไม่สามารถรวบรวมได้

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

เอาท์พุต

Inline: Overloaded == เรียกว่า

สามัญ:

กดปุ่มใดก็ได้เพื่อดำเนินการต่อ . .

ติดตาม 2

ฉันต้องการชี้ให้เห็นว่าการเปลี่ยนวิธีเปรียบเทียบของฉันเป็น

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

ทำให้โอเปอเรเตอร์ == โอเวอร์โหลดถูกเรียก ฉันเดาโดยไม่ระบุประเภท (เป็นที่ ) คอมไพเลอร์ไม่สามารถอนุมานได้ว่าควรใช้โอเปอเรเตอร์ที่โอเวอร์โหลด ... แม้ว่าฉันคิดว่ามันจะมีข้อมูลเพียงพอที่จะทำการตัดสินใจแม้ว่าจะไม่ได้ระบุ

อย่างที่คนอื่น ๆ พูดกันมันจะใช้ได้ก็ต่อเมื่อ T ถูกบังคับให้เป็นประเภทอ้างอิง โดยไม่มีข้อ จำกัด ใด ๆ คุณสามารถเปรียบเทียบกับค่าว่าง แต่เป็นค่าว่างเท่านั้นและการเปรียบเทียบนั้นจะเป็นเท็จสำหรับประเภทค่าที่ไม่เป็นค่าว่างเสมอ

แทนที่จะโทรเท่ากับจะเป็นการดีกว่าที่จะใช้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มีการใช้งานที่แตกต่างกันด้วยเหตุผลบางประการงานของฉันเกี่ยวกับตัวดำเนินการทั่วไปควรมีประโยชน์ มันรองรับเวอร์ชั่นโอเปอเรเตอร์ของ (ในหมู่อื่น ๆ ):

• เท่ากับ (T value1, T value2)
• NotEqual (T value1, T value2)
• GreaterThan (ค่า T 1 ค่า T 2)
• LessThan (T value1, T value2)
• Greaterhan มาตรฐาน (ค่า T 1 ค่า T 2)
• น้อยกว่าหรือมาตรฐาน (ค่า T 1, T ค่า 2)

มีคำตอบมากมายและไม่ใช่เพียงคำเดียวอธิบายว่าทำไม (ซึ่ง Giovanni ถามอย่างชัดเจน) ...

.NET generics ไม่ได้ทำตัวเหมือนแม่แบบ C ++ ใน C ++ เท็มเพลตการแก้ไขการโอเวอร์โหลดเกิดขึ้นหลังจากทราบพารามิเตอร์เท็มเพลตจริง

ใน. NET generics (รวมถึง C #) การแก้ปัญหาการโอเวอร์โหลดเกิดขึ้นโดยไม่ทราบถึงพารามิเตอร์ทั่วไปที่แท้จริง ข้อมูลเท่านั้นที่คอมไพเลอร์สามารถใช้เพื่อเลือกฟังก์ชั่นที่จะโทรมาจากข้อ จำกัด ประเภทกับพารามิเตอร์ทั่วไป

คอมไพล์ไม่ทราบว่า T ไม่สามารถเป็น struct ได้ (ชนิดของค่า) ดังนั้นคุณต้องบอกว่ามันเป็นประเภทอ้างอิงเท่านั้นฉันคิดว่า:

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 ที่ทำโดยประโยคที่

ปรากฏว่าไม่มีข้อ จำกัด ของคลาส:

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

หนึ่งควรตระหนักว่าในขณะที่classมีข้อ จำกัดEqualsใน==สืบทอดจากผู้ประกอบการในขณะที่ของการแทนที่Object.Equals structValueType.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 สำหรับที่นี่

การตอบกลับของ Alex Turner เริ่มต้นด้วย:

น่าเสียดายที่พฤติกรรมนี้เกิดจากการออกแบบและไม่มีวิธีแก้ปัญหาที่ง่ายในการเปิดใช้งาน == พร้อมพารามิเตอร์ประเภทที่อาจมีประเภทของค่า

หากคุณต้องการให้แน่ใจว่าตัวดำเนินการประเภทที่กำหนดเองของคุณถูกเรียกว่าคุณสามารถทำได้ผ่านการสะท้อนกลับ รับชนิดโดยใช้พารามิเตอร์ทั่วไปของคุณและเรียกใช้ MethodInfo สำหรับโอเปอเรเตอร์ที่ต้องการ (เช่น op_Equality, op_Inequality, op_LessThan ... )

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

จากนั้นดำเนินการตัวดำเนินการโดยใช้วิธีการเรียกใช้เมธอด InvInfo และส่งผ่านวัตถุเป็นพารามิเตอร์

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


    // ...
}