สิ่งห่อหุ้มควรเปรียบเทียบให้เท่ากันโดยใช้ตัวดำเนินการ == เมื่อทำการล้อมวัตถุเดียวกันหรือไม่?

ฉันกำลังเขียน wrapper สำหรับองค์ประกอบ XML ที่ช่วยให้นักพัฒนาสามารถวิเคราะห์แอตทริบิวต์จาก XML ได้อย่างง่ายดาย เสื้อคลุมไม่มีสถานะอื่นนอกจากวัตถุที่ถูกห่อ

ฉันกำลังพิจารณาการติดตั้งต่อไปนี้ (ทำให้ง่ายขึ้นสำหรับตัวอย่างนี้) ซึ่งรวมถึงโอเวอร์โหลดสำหรับ==โอเปอเรเตอร์

class XmlWrapper
{
    protected readonly XElement _element;

    public XmlWrapper(XElement element)
    {
        _element = element;
    }

    public string NameAttribute
    {
        get
        {
            //Get the value of the name attribute
        }
        set
        {
            //Set the value of the name attribute
        }
    }

    public override bool Equals(object other)
    {
        var o = other as XmlWrapper;
        if (o == null) return false;
        return _element.Equals(o._element);
    }

    public override int GetHashCode()
    {
        return _element.GetHashCode();
    }

    static public bool operator == (XmlWrapper lhs, XmlWrapper rhs)
    {
        if (ReferenceEquals(lhs, null) && ReferenceEquals(rhs, null)) return true;
        if (ReferenceEquals(lhs, null) || ReferenceEquals(rhs, null)) return false;

        return lhs._element == rhs._element;
    }

    static public bool operator != (XmlWrapper lhs, XmlWrapper rhs)
    {
        return !(lhs == rhs);
    }
}

ตามที่ฉันเข้าใจสำนวน c # ==ผู้ปฏิบัติงานมีไว้สำหรับความเท่าเทียมในการอ้างอิงในขณะที่Equals()วิธีการสำหรับความเท่าเทียมกันของค่า แต่ในกรณีนี้ "ค่า" เป็นเพียงการอ้างอิงถึงวัตถุที่ถูกห่อ ดังนั้นฉันจึงไม่ชัดเจนว่าสิ่งที่เป็นธรรมดาหรือสำนวนสำหรับ c #

ตัวอย่างเช่นในรหัสนี้ ...

var underlyingElement = new XElement("Foo");
var a = new XmlWrapper(underlyingElement);
var b = new XmlWrapper(underlyingElement);

a.NameAttribute = "Hello";
b.NameAttribute = "World";

if (a == b)
{
    Console.WriteLine("The wrappers a and b are the same.");
}

เอาท์พุทของโปรแกรม .... "ตัวห่อ a และ b เหมือนกัน"? หรือว่าจะแปลกคือละเมิดหลักความประหลาดใจอย่างน้อย ?

เนื่องจากการอ้างอิงถึงสิ่งห่อหุ้มXElementไม่สามารถเปลี่ยนแปลงได้จึงไม่มีความแตกต่างที่สังเกตได้จากภายนอกทั้งสองกรณีของXmlWrapperองค์ประกอบเดียวกันดังนั้นจึงเหมาะสมที่==จะสะท้อนความจริงนี้

รหัสลูกค้ามักจะใส่ใจเกี่ยวกับความเสมอภาคเชิงตรรกะ (ซึ่งโดยค่าเริ่มต้นจะมีการใช้งานโดยใช้ความเท่าเทียมกันอ้างอิงสำหรับประเภทการอ้างอิง) ความจริงที่ว่ามีสองอินสแตนซ์บนฮีปคือรายละเอียดการใช้งานที่ลูกค้าไม่ควรสนใจ (และผู้ที่จะใช้Object.ReferenceEqualsโดยตรง)

ถ้าคุณคิดว่ามันสมเหตุสมผลที่สุด

คำถามและคำตอบนั้นเป็นเรื่องของความคาดหวังของนักพัฒนาซึ่งไม่ใช่ข้อกำหนดทางเทคนิค

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

แต่นี่เป็นปัญหาที่เกิดซ้ำ ควรห่อสองรายการแสดงความเท่าเทียมกันเมื่อพวกเขาห่อวัตถุที่แตกต่างกัน แต่มีวัตถุทั้งสองที่มีเนื้อหาเดียวกันแน่นอน?

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

มันturtles ตลอดทางลง

เคล็ดลับทั่วไป

เมื่อใดก็ตามที่คุณเบี่ยงเบนจากพฤติกรรมเริ่มต้นควรมีการบันทึกไว้อย่างชัดเจน ในฐานะนักพัฒนาฉันคาดหวังว่าการอ้างอิงสองประเภทจะไม่แสดงความเท่าเทียมกันแม้ว่าเนื้อหานั้นจะเท่ากัน หากคุณเปลี่ยนพฤติกรรมนั้นฉันขอแนะนำให้คุณบันทึกไว้อย่างชัดเจนเพื่อให้นักพัฒนาซอฟต์แวร์ทุกคนทราบถึงพฤติกรรมผิดปกตินี้

ตามที่ฉันเข้าใจสำนวน c # ==ผู้ปฏิบัติงานมีไว้สำหรับความเท่าเทียมในการอ้างอิงในขณะที่Equals()วิธีการสำหรับความเท่าเทียมกันของค่า

นั่นคือพฤติกรรมเริ่มต้น แต่นี่ไม่ใช่กฎที่เคลื่อนที่ไม่ได้ มันเป็นเรื่องของการประชุม แต่การประชุมสามารถเปลี่ยนแปลงที่สมเหตุสมผล

stringเป็นตัวอย่างที่ดีที่นี่เช่นเดียวกับ==การตรวจสอบความเท่าเทียมกันของค่า (แม้ว่าจะไม่มีการฝึกงานสตริง!) ทำไม? พูดง่ายๆ: เนื่องจากการมีสตริงทำตัวเหมือนวัตถุที่ให้คุณค่าจึงทำให้นักพัฒนาส่วนใหญ่ใช้งานง่ายขึ้น

ถ้า codebase ของคุณ (หรือชีวิตของนักพัฒนาของคุณ) ได้ง่ายสะดุดตาโดยมีห่อของคุณแสดงความเสมอภาคค่าผ่านคณะกรรมการไปได้ ( แต่เอกสารมัน )

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

คุณกำลังเปรียบเทียบสตริงโดยทั่วไปดังนั้นฉันจะประหลาดใจถ้าสอง wrappers ที่มีเนื้อหา XML เดียวกันนั้นไม่ถือว่าเท่ากันไม่ว่าจะตรวจสอบโดยใช้ Equals หรือ ==

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

Wrapper Postfix ของคุณเพิ่มความสับสน โดยพื้นฐานแล้วจะพูดว่า "ไม่ใช่องค์ประกอบ XML" ดังนั้นฉันควรปฏิบัติต่อมันเป็นประเภทอ้างอิงหลังจากทั้งหมดหรือไม่ ความหมายนี้จะไม่สมเหตุสมผล ฉันจะสับสนน้อยลงถ้าคลาสมีชื่อว่า XmlContent สิ่งนี้จะส่งสัญญาณว่าเราใส่ใจเนื้อหาไม่ใช่รายละเอียดการใช้งานด้านเทคนิค