เหตุใด (object) 0 == (object) 0 จึงแตกต่างจาก ((object) 0) .Equals ((object) 0)?

เหตุใดนิพจน์ต่อไปนี้จึงแตกต่างกัน

[1]  (object)0 == (object)0 //false
[2]  ((object)0).Equals((object)0) // true

อันที่จริงฉันสามารถเข้าใจ [1] ได้ทั้งหมดเพราะรันไทม์. NET อาจboxเป็นจำนวนเต็มและเริ่มเปรียบเทียบการอ้างอิงแทน แต่ทำไม [2] จึงแตกต่างกัน?

เหตุผลที่การโทรมีพฤติกรรมแตกต่างกันคือพวกเขาเชื่อมโยงกับวิธีการที่แตกต่างกันมาก

==กรณีที่จะเชื่อมโยงกับผู้ประกอบการอ้างอิงความเท่าเทียมกันคงที่ มีการintสร้างค่ากล่องอิสระ 2 ค่าดังนั้นจึงไม่ใช่การอ้างอิงเดียวกัน

Object.Equalsในกรณีที่สองคุณผูกกับวิธีการเช่น นี่เป็นวิธีการเสมือนจริงที่จะกรองลงไปInt32.Equalsและจะตรวจสอบจำนวนเต็มกล่อง ค่าจำนวนเต็มทั้งสองเป็น 0 จึงมีค่าเท่ากัน

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

ในทางกลับกันเมื่อคุณใช้Equalsซึ่งเป็นวิธีการเสมือนจริงจะใช้การใช้งานชนิดบรรจุกล่องจริงนั่นคือInt32.Equalsส่งคืนค่าจริงเนื่องจากวัตถุทั้งสองมีค่าเท่ากัน

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

Equalsวิธีเป็นวิธีการเช่นเสมือน มันจะรันโค้ดที่กำหนดไว้ในประเภทรันไทม์จริงของอ็อบเจ็กต์ (แรก) ไม่ใช่โค้ดในobjectคลาส ในกรณีนี้ออบเจ็กต์คือ an intดังนั้นมันจะทำการเปรียบเทียบค่าเนื่องจากเป็นสิ่งที่intประเภทกำหนดสำหรับEqualsวิธีการของมัน

Equals()วิธีเป็นเสมือน
ดังนั้นจึงมักจะเรียกใช้งานคอนกรีตแม้เมื่อ callsite objectจะหล่อไป intแทนที่Equals()เพื่อเปรียบเทียบตามค่าเพื่อให้คุณได้รับการเปรียบเทียบมูลค่า

== ใช้: Object.ReferenceEquals

Object.Equals เปรียบเทียบมูลค่า

object.ReferenceEqualsวิธีการเปรียบเทียบอ้างอิง เมื่อคุณจัดสรรวัตถุคุณจะได้รับการอ้างอิงที่มีค่าที่ระบุตำแหน่งหน่วยความจำนอกเหนือจากข้อมูลของวัตถุบนฮีปหน่วยความจำ

object.Equalsวิธีการเปรียบเทียบเนื้อหาของวัตถุ ขั้นแรกจะตรวจสอบว่าการอ้างอิงนั้นเท่ากันหรือไม่เช่นเดียวกับ object.ReferenceEquals แต่จากนั้นก็เรียกใช้วิธี Equals ที่ได้รับมาเพื่อทดสอบความเท่าเทียม ดูนี่:

   System.Object a = new System.Object();
System.Object b = a;
System.Object.ReferenceEquals(a, b);  //returns true

ตัวดำเนินการ C # ใช้โทเค็น==เพื่อแสดงตัวดำเนินการสองตัวที่แตกต่างกัน: ตัวดำเนินการเปรียบเทียบแบบคงที่ - โอเวอร์โหลดได้และตัวดำเนินการเปรียบเทียบการอ้างอิงที่ไม่โอเวอร์โหลด เมื่อพบ==โทเค็นขั้นแรกจะตรวจสอบว่ามีโอเวอร์โหลดการทดสอบความเท่าเทียมกันหรือไม่ซึ่งใช้ได้กับประเภทตัวถูกดำเนินการ ถ้าเป็นเช่นนั้นมันจะเรียกว่าโอเวอร์โหลด มิฉะนั้นจะตรวจสอบว่าประเภทนั้นใช้ได้กับตัวดำเนินการเปรียบเทียบข้อมูลอ้างอิงหรือไม่ ถ้าเป็นเช่นนั้นก็จะใช้ตัวดำเนินการนั้น หากไม่มีตัวดำเนินการใดที่สามารถใช้ได้กับชนิดตัวถูกดำเนินการการคอมไพล์จะล้มเหลว

โค้ด(Object)0ไม่ได้เป็นเพียงการอัปเดตInt32ถึงObject: Int32เช่นเดียวกับประเภทค่าทั้งหมดจริง ๆ แล้วแสดงถึงสองประเภทซึ่งหนึ่งในนั้นอธิบายถึงค่าและตำแหน่งที่จัดเก็บ (เช่นศูนย์ตามตัวอักษร) แต่ไม่ได้มาจากสิ่งใดเลยและหนึ่งในนั้นอธิบายถึง กองวัตถุและมาจากObject; เนื่องจากเฉพาะประเภทหลังเท่านั้นที่สามารถอัปเดObjectตได้คอมไพเลอร์ต้องสร้างวัตถุฮีปใหม่ของประเภทหลังนั้น การเรียกใช้แต่ละครั้งของ(Object)0สร้างฮีปอ็อบเจ็กต์ใหม่ดังนั้นตัวถูกดำเนินการทั้งสอง==จึงเป็นอ็อบเจ็กต์ที่แตกต่างกันซึ่งแต่ละอ็อพชันจะห่อหุ้มInt32ค่า 0 โดยอิสระ

คลาสObjectไม่มีโอเวอร์โหลดที่ใช้งานได้ซึ่งกำหนดไว้สำหรับตัวดำเนินการเท่ากับ ดังนั้นคอมไพลเลอร์จะไม่สามารถใช้ตัวดำเนินการทดสอบความเท่าเทียมกันที่โอเวอร์โหลดและจะถอยกลับไปใช้การทดสอบความเท่าเทียมกันของการอ้างอิง เพราะทั้งสองตัวถูกดำเนินการที่จะอ้างถึงวัตถุที่แตกต่างกันก็จะรายงาน== falseการเปรียบเทียบครั้งที่สองทำได้สำเร็จเนื่องจากถามอินสแตนซ์ฮีปอ็อบเจ็กต์หนึ่งInt32ว่าเท่ากับอีกหรือไม่ เนื่องจากอินสแตนซ์นั้นรู้ว่าการเท่ากับอินสแตนซ์อื่นที่แตกต่างกันหมายความว่าอย่างไรจึงสามารถตอบtrueได้

การตรวจสอบทั้งสองแบบแตกต่างกัน คนแรกที่ตรวจสอบตัวตนที่หนึ่งที่สองสำหรับความเท่าเทียมกัน โดยทั่วไปคำศัพท์สองคำจะเหมือนกันหากอ้างถึงวัตถุเดียวกัน นี่หมายความว่าพวกเขาเท่าเทียมกัน คำสองคำมีค่าเท่ากันถ้าค่าเท่ากัน

ในแง่ของเอกลักษณ์การเขียนโปรแกรมมักจะยุ่งเหยิงด้วยความเท่าเทียมกันในการอ้างอิง หากตัวชี้ของทั้งสองคำมีค่าเท่ากัน (!) วัตถุที่พวกเขาชี้ไปจะเหมือนกันทุกประการ อย่างไรก็ตามหากพอยน์เตอร์แตกต่างกันค่าของอ็อบเจ็กต์ที่ชี้ไปจะยังคงเท่ากัน ใน C # ตัวตนสามารถตรวจสอบได้โดยใช้สถิตย์Object.ReferenceEqualsสมาชิกในขณะที่มีการตรวจสอบความเสมอภาคใช้ไม่คงที่Object.Equalsสมาชิก เนื่องจากคุณหล่อจำนวนเต็มสองจำนวนวัตถุ (ซึ่งเรียกว่า "มวย" BTW) operatior ==ของobjectดำเนินการตรวจสอบครั้งแรกซึ่งเป็นค่าเริ่มต้นแมปไปObject.ReferenceEqualsและการตรวจสอบตัวตน หากความชัดเจนของคุณเรียกEqualsสมาชิกแบบไม่คงที่การจัดส่งแบบไดนามิกจะส่งผลให้เกิดการเรียกร้องInt32.Equalsซึ่งจะตรวจสอบความเท่าเทียมกัน

แนวคิดทั้งสองมีความคล้ายคลึงกัน แต่ไม่เหมือนกัน พวกเขาอาจดูสับสนในตอนแรก แต่ความแตกต่างเล็กน้อยนั้นสำคัญมาก! ลองนึกภาพบุคคล 2 คน ได้แก่ "อลิซ" และ "บ็อบ" ทั้งคู่อาศัยอยู่ในบ้านสีเหลือง จากการสันนิษฐานว่าอลิซและบ็อบอาศัยอยู่ในเขตหนึ่งซึ่งบ้านมีสีแตกต่างกันเท่านั้นพวกเขาทั้งคู่อาศัยอยู่ในบ้านสีเหลืองที่แตกต่างกัน หากเปรียบบ้านทั้งสองหลังคุณจะจำได้ว่าบ้านทั้งสองหลังนั้นเหมือนกันอย่างแน่นอนเพราะทั้งสองหลังมีสีเหลือง! แต่พวกเขาจะไม่ร่วมกันที่บ้านเดียวกันและทำให้บ้านของพวกเขาจะเท่ากันแต่ไม่เหมือนกัน อัตลักษณ์บ่งบอกว่าพวกเขาอาศัยอยู่ในบ้านหลังเดียวกัน

หมายเหตุ : บางภาษากำลังกำหนดตัว===ดำเนินการเพื่อตรวจสอบตัวตน