IEqualityComparer <T> และ IEquatable <T> แตกต่างกันอย่างไร

ฉันต้องการที่จะเข้าใจสถานการณ์ที่IEqualityComparer<T>และIEquatable<T>ควรจะใช้ เอกสาร MSDN ของทั้งคู่มีลักษณะคล้ายกันมาก

IEqualityComparer<T>Tเป็นอินเตอร์เฟซสำหรับวัตถุที่ดำเนินการเปรียบเทียบวัตถุสองชนิดที่

IEquatable<T>สำหรับวัตถุประเภทTเพื่อให้สามารถเปรียบเทียบตัวเองกับประเภทอื่นที่เหมือนกัน

เมื่อตัดสินใจว่าจะใช้IEquatable<T>หรือIEqualityComparer<T>มีใครถาม:

มีวิธีที่ต้องการในการทดสอบสองอินสแตนซ์ของTเพื่อความเท่าเทียมกันหรือมีหลายวิธีที่ถูกต้องเท่าเทียมกัน?

• หากมีเพียงวิธีเดียวในการทดสอบสองอินสแตนซ์ของTความเท่าเทียมกันหรือหากหนึ่งในหลายวิธีที่ต้องการนั้นIEquatable<T>จะเป็นตัวเลือกที่ถูกต้อง: อินเทอร์เฟซนี้ควรจะดำเนินการด้วยTตัวเองเท่านั้นดังนั้นอินสแตนซ์เดียวTของ Tวิธีการเปรียบเทียบตัวเองไปอินสแตนซ์ของผู้อื่น

• ในทางกลับกันหากมีวิธีการที่เหมาะสมหลายวิธีในการเปรียบเทียบสองTs เพื่อความเท่าเทียมกันนั้นIEqualityComparer<T>จะดูเหมาะสมกว่า: อินเตอร์เฟสนี้ไม่ได้หมายถึงการใช้งานด้วยTตัวเอง แต่โดยคลาสอื่น ๆ "ภายนอก" ดังนั้นเมื่อทดสอบสองอินสแตนซ์ของTเพื่อความเท่าเทียมกันเนื่องจากTไม่มีความเข้าใจภายในเกี่ยวกับความเสมอภาคคุณจะต้องเลือกอย่างชัดเจนของIEqualityComparer<T>อินสแตนซ์ที่ดำเนินการทดสอบตามข้อกำหนดเฉพาะของคุณ

ตัวอย่าง:

ลองพิจารณาสองประเภทนี้ (ซึ่งควรจะมีความหมายตามตัวอักษร ):

interface IIntPoint : IEquatable<IIntPoint>
{
    int X { get; }
    int Y { get; }
}

interface IDoublePoint  // does not inherit IEquatable<IDoublePoint>; see below.
{
    double X { get; }
    double Y { get; }
}

ทำไมประเภทเหล่านี้เพียงประเภทเดียวจึงสืบทอดIEquatable<>แต่ไม่ใช่ประเภทอื่น

ในทางทฤษฎีมีเพียงวิธีเดียวที่สมเหตุสมผลในการเปรียบเทียบสองอินสแตนซ์ของทั้งสองประเภท: พวกเขาจะเท่ากันถ้าXและYคุณสมบัติในทั้งสองกรณีเท่ากัน ตามความคิดนี้ทั้งสองประเภทควรนำมาใช้IEquatable<>เพราะดูเหมือนว่ามีวิธีอื่นที่มีความหมายในการทำแบบทดสอบความเท่าเทียมกัน

ปัญหาที่นี่คือการเปรียบเทียบจำนวนจุดลอยตัวเพื่อความเท่าเทียมกันอาจจะไม่ทำงานตามที่คาดไว้เนื่องจากข้อผิดพลาดนาทีปัดเศษ มีวิธีการที่แตกต่างกันในการเปรียบเทียบตัวเลขทศนิยมสำหรับความเท่าเทียมกันโดยแต่ละวิธีมีข้อดีและข้อเสียต่างกันและคุณอาจต้องการเลือกวิธีที่เหมาะสม

sealed class DoublePointNearEqualityComparerByTolerance : IEqualityComparer<IDoublePoint>
{
    public DoublePointNearEqualityComparerByTolerance(double tolerance) { … }
    …
    public bool Equals(IDoublePoint a, IDoublePoint b)
    {
        return Math.Abs(a.X - b.X) <= tolerance  &&  Math.Abs(a.Y - b.Y) <= tolerance;
    }
    …
}

โปรดทราบว่าหน้าเว็บที่ฉันเชื่อมโยงกับ (ด้านบน) ระบุอย่างชัดเจนว่าการทดสอบความเท่าเทียมกันนี้มีจุดอ่อนบางอย่าง เนื่องจากนี่เป็นการIEqualityComparer<T>ใช้งานคุณสามารถสลับมันได้ถ้ามันไม่ดีพอสำหรับวัตถุประสงค์ของคุณ

คุณมีคำจำกัดความพื้นฐานของสิ่งที่พวกเขาเป็นอยู่แล้ว ในระยะสั้นหากคุณใช้IEquatable<T>ในระดับTที่Equalsวิธีการเกี่ยวกับวัตถุของการพิมพ์ที่Tบอกคุณว่าวัตถุเอง (อย่างใดอย่างหนึ่งที่มีการทดสอบเพื่อความเท่าเทียมกัน) Tจะมีค่าเท่ากับตัวอย่างของประเภทเดียวกันอีก ในขณะที่IEqualityComparer<T>เป็นสำหรับการทดสอบความเท่าเทียมกันของสองกรณีของโดยทั่วไปนอกขอบเขตของอินสแตนซ์ของTT

สำหรับสิ่งที่พวกเขากำลังจะสับสนในตอนแรก จากคำนิยามมันควรจะชัดเจนว่าด้วยเหตุนี้IEquatable<T>(กำหนดไว้ในคลาสTเอง) ควรเป็นมาตรฐาน de พฤตินัยเพื่อแสดงถึงเอกลักษณ์ของวัตถุ / อินสแตนซ์ HashSet<T>, Dictionary<T, U>(พิจารณาGetHashCodeจะถูกแทนเช่นกัน) ContainsในList<T>ฯลฯ ทำให้การใช้นี้ การดำเนินการIEqualityComparer<T>เกี่ยวกับการTไม่ได้ช่วยดังกล่าวข้างต้นกรณีทั่วไป ต่อจากนั้นมีค่าน้อยสำหรับการใช้งานIEquatable<T>ในชั้นอื่น ๆ นอกเหนือจากTนี้ นี้:

class MyClass : IEquatable<T>

ไม่ค่อยมีเหตุผล

ในทางกลับกัน

class T : IEquatable<T>
{
    //override ==, !=, GetHashCode and non generic Equals as well

    public bool Equals(T other)
    {
        //....
    }
}

มันควรจะทำอย่างไร

IEqualityComparer<T>อาจมีประโยชน์เมื่อคุณต้องการการตรวจสอบความเท่าเทียมกันแบบกำหนดเอง แต่ไม่ใช่กฎทั่วไป ตัวอย่างเช่นในชั้นเรียนPersonณ จุดหนึ่งคุณอาจต้องทดสอบความเท่าเทียมกันของคนสองคนตามอายุของพวกเขา ในกรณีนี้คุณสามารถทำได้:

class Person
{
    public int Age;
}

class AgeEqualityTester : IEqualityComparer<Person>
{
    public bool Equals(Person x, Person y)
    {
        return x.Age == y.Age;
    }

    public int GetHashCode(Person obj)
    {
        return obj.Age.GetHashCode;
    }
}

เพื่อทดสอบพวกเขาลอง

var people = new Person[] { new Person { age = 23 } };
Person p = new Person() { age = 23 };

print people.Contains(p); //false;
print people.Contains(p, new AgeEqualityTester()); //true

ในทำนองเดียวกันIEqualityComparer<T>ที่Tไม่สมเหตุสมผล

class Person : IEqualityComparer<Person>

ใช้งานได้จริง แต่ดูไม่ดีต่อสายตาและเอาชนะตรรกะ

IEquatable<T>โดยปกติแล้วสิ่งที่คุณต้องการ นอกจากนี้ในอุดมคติคุณสามารถมีเพียงหนึ่งIEquatable<T>ในขณะที่หลาย ๆIEqualityComparer<T>เป็นไปได้ตามเกณฑ์ที่แตกต่าง

IEqualityComparer<T>และIEquatable<T>เป็นสิ่งที่คล้ายคลึงกับComparer<T>และIComparable<T>ซึ่งจะใช้เพื่อการเปรียบเทียบมากกว่าเท่า; หัวข้อที่ดีที่นี่ที่ฉันเขียนคำตอบเดียวกัน :)

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

IEquatable สำหรับวัตถุนั้นเอง (สิ่งหนึ่งที่ถูกนำมาเปรียบเทียบเพื่อความเท่าเทียมกัน) เพื่อนำไปใช้

หนึ่งเปรียบเทียบสองTs อื่น ๆ ที่สามารถเปรียบเทียบตัวเองกับคนอื่น ๆTs โดยปกติคุณจะต้องใช้งานครั้งละหนึ่งรายการเท่านั้นไม่ใช่ทั้งสองอย่าง