พิจารณารหัสนี้:

int age = 25;
short newAge = 25;
Console.WriteLine(age == newAge);  //true
Console.WriteLine(newAge.Equals(age)); //false
Console.ReadLine();

ทั้งสองintและshortเป็นประเภทดั้งเดิม แต่การเปรียบเทียบกับ==ผลตอบแทนจริงและเปรียบเทียบกับEqualsผลตอบแทนที่เป็นเท็จ

ทำไม?

คำตอบสั้น ๆ :

ความเท่าเทียมกันนั้นซับซ้อน

คำตอบโดยละเอียด:

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

เนื่องจากnewAgeเป็น a short, Equals(object)เมธอดของมันจะคืนค่าเป็นจริงถ้าคุณผ่านการย่อบ็อกซ์ด้วยค่าเดียวกัน คุณกำลังส่งกล่องintแล้วมันจะส่งกลับเท็จ

ในทางตรงกันข้าม==ผู้ปฏิบัติงานจะถูกกำหนดให้รับค่าสองints (หรือshorts หรือlongs)
เมื่อคุณเรียกมันด้วยinta และ a shortคอมไพเลอร์จะแปลงค่าshortเป็นintและเปรียบเทียบผลลัพธ์ints โดยค่า

วิธีอื่น ๆ ในการทำให้มันใช้งานได้

ประเภทดั้งเดิมมีEquals()วิธีการของตนเองที่ยอมรับประเภทเดียวกัน
ถ้าคุณเขียนage.Equals(newAge)คอมไพเลอร์จะเลือกint.Equals(int)เป็นเกินที่ดีที่สุดและโดยปริยายแปลงไปshort intมันจะกลับมาtrueเนื่องจากวิธีนี้จะเปรียบเทียบints โดยตรง

shortยังมีshort.Equals(short)วิธีการ แต่intไม่สามารถแปลงเป็นโดยปริยายshortดังนั้นคุณไม่ได้เรียกมัน

คุณสามารถบังคับให้เรียกวิธีนี้โดยใช้นักแสดง:

Console.WriteLine(newAge.Equals((short)age)); // true

วิธีนี้จะโทรshort.Equals(short)โดยตรงโดยไม่ต้องชกมวย หากageมีขนาดใหญ่กว่า 32767 จะเป็นการยกเว้นข้อยกเว้นมากเกินไป

คุณสามารถเรียกshort.Equals(object)โอเวอร์โหลดได้ แต่ผ่านวัตถุที่บรรจุอยู่ในกล่องอย่างชัดเจนเพื่อให้ได้ชนิดเดียวกัน:

Console.WriteLine(newAge.Equals((object)(short)age)); // true

shortเช่นเดียวกับทางเลือกที่ก่อนหน้านี้จะโยนล้นถ้ามันไม่พอดีใน แตกต่างจากโซลูชันก่อนหน้านี้มันจะบรรจุshortลงในวัตถุเสียเวลาและหน่วยความจำ

รหัสแหล่งที่มา:

นี่คือทั้งสองEquals()วิธีจากซอร์สโค้ดจริง:

    public override bool Equals(Object obj) {
        if (!(obj is Int16)) {
            return false;
        }
        return m_value == ((Int16)obj).m_value;
    }

    public bool Equals(Int16 obj)
    {
        return m_value == obj;
    }

อ่านเพิ่มเติม:

ดูเอริค Lippert

เพราะไม่มีการโอเวอร์โหลดสำหรับที่ยอมรับshort.Equals intดังนั้นสิ่งนี้จึงถูกเรียกว่า:

public override bool Equals(object obj)
{
    return obj is short && this == (short)obj;
}

objไม่ใช่short.. ดังนั้นมันจึงเป็นเท็จ

เมื่อคุณผ่านintไปยังshortเท่ากับคุณผ่านobject:

ดังนั้น pseudocode นี้จึงทำงาน:

return obj is short && this == (short)obj;

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

Object.Equals
http://msdn.microsoft.com/en-us/library/bsc2ak47(v=vs.110).aspx

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

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

int x=1;
short y=1;
x==y;//true
y.Equals(x);//false

ในตัวอย่างด้านบน X และ Y มีค่าเหมือนกันคือ 1 และเมื่อเราใช้==มันจะคืนค่าจริงเช่นเดียวกับในกรณีของ==ประเภทสั้นจะถูกแปลงเป็น int โดยคอมไพเลอร์และให้ผลลัพธ์

และเมื่อเราใช้Equalsการเปรียบเทียบเสร็จสิ้น แต่การหล่อประเภทไม่ได้กระทำโดยคอมไพเลอร์ดังนั้นจึงส่งคืนค่าเท็จ

พวกโปรดแจ้งให้เราทราบหากฉันผิด

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

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

หากหนึ่งใช้==ประกอบการที่จะเปรียบเทียบshortและintที่จะถูกแปลงโดยปริยายไปยังshort intถ้าค่าตัวเลขของมันเท่ากับว่าจากintการintที่มันถูกดัดแปลงจะเท่ากับintที่มันจะถูกเปรียบเทียบ หากหนึ่งในความพยายามที่จะใช้Equalsวิธีการในระยะสั้นเพื่อเปรียบเทียบด้วยintแต่การแปลงเท่านั้นโดยปริยายซึ่งจะตอบสนองเกินของวิธีการที่จะแปลงชนิดของวัตถุที่สอดคล้องกับEquals intเมื่อshortมีการถามว่ามันตรงกับวัตถุที่ส่งผ่านหรือไม่มันจะสังเกตว่าวัตถุที่เป็นปัญหานั้นเป็นintมากกว่าshortและดังนั้นจึงสรุปได้ว่ามันไม่สามารถเท่ากับ

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

int i = 16777217;
float f = 16777216.0f;

Console.WriteLine("{0}", i==f);

มีสามวิธีในที่หนึ่งอาจต้องการที่จะเปรียบเทียบเป็นไปint floatหนึ่งอาจต้องการที่จะรู้ว่า:

1. ค่าที่ใกล้เคียงที่สุดที่เป็นไปได้floatในการintแข่งขันfloatคือ
2. ส่วนจำนวนทั้งหมดของการfloatแข่งขันintหรือไม่
3. ทำintและfloatแทนค่าตัวเลขเดียวกัน

หากพยายามเปรียบเทียบintและfloatโดยตรงรหัสที่คอมไพล์จะตอบคำถามแรก ไม่ว่าจะเป็นสิ่งที่โปรแกรมเมอร์ตั้งใจจะอยู่ไกลจากที่เห็นได้ชัด การเปลี่ยนการเปรียบเทียบ(float)i == fจะทำให้ชัดเจนว่าความหมายแรกนั้นตั้งใจไว้หรือ(double)i == (double)fจะทำให้โค้ดตอบคำถามที่สาม (และทำให้ชัดเจนว่าเป็นสิ่งที่ตั้งใจ)

(*) แม้ว่า C # spec จะพิจารณาถึงคุณค่าของประเภทเช่นSystem.Int32ว่าเป็นวัตถุประเภทSystem.Int32มุมมองดังกล่าวจะขัดแย้งกับข้อกำหนดที่โค้ดรันบนแพลตฟอร์มที่สเป็กนับถือค่าและวัตถุที่อาศัยอยู่ในจักรวาลที่แตกต่างกัน นอกจากนี้ถ้าTเป็นชนิดอ้างอิงและxเป็นTแล้วอ้างอิงจากประเภทนี้ควรจะสามารถที่จะอ้างถึงT xดังนั้นหากตัวแปรvประเภทInt32มีObjectการอ้างอิงประเภทObjectควรจะสามารถเก็บการอ้างอิงถึงvหรือเนื้อหา ในความเป็นจริงการอ้างอิงประเภทObjectจะสามารถชี้ไปยังวัตถุที่เก็บข้อมูลที่คัดลอกมาจากvแต่ไม่ถึงvตัวมันเองหรือเนื้อหา ที่จะแนะนำว่าไม่vObjectมิได้เนื้อหาของมันเป็นจริง

Equals () เป็นเมธอดของSystem.Object Class
ไวยากรณ์: Public bool เสมือน Equals () การ
แนะนำถ้าเราต้องการเปรียบเทียบสถานะของวัตถุสองตัวเราควรใช้วิธี Equals ()

ตามที่ระบุไว้ข้างต้นคำตอบ==ผู้ประกอบการเปรียบเทียบค่าเหมือนกัน

โปรดอย่าสับสนกับ ReferenceEqual

Reference Equals ()
ไวยากรณ์: public static bool ReferenceEquals ()
กำหนดว่าอินสแตนซ์วัตถุที่ระบุนั้นเป็นอินสแตนซ์เดียวกันหรือไม่

สิ่งที่คุณต้องตระหนักคือการทำ==มักจะจบลงด้วยการเรียกวิธีการ คำถามคือว่าการโทร==และEqualsจบลงด้วยการโทร / ทำสิ่งเดียวกัน

ด้วยประเภทการอ้างอิง==จะทำการตรวจสอบที่ 1 เสมอว่าการอ้างอิงนั้นเหมือนกัน ( Object.ReferenceEquals) Equalsในทางกลับกันสามารถแทนที่ได้และอาจตรวจสอบว่าค่าบางค่าเท่ากันหรือไม่

แก้ไข: เพื่อตอบ svick และเพิ่มความคิดเห็น SLaks นี่คือรหัส IL

int i1 = 0x22; // ldc.i4.s ie pushes an int32 on the stack
int i2 = 0x33; // ldc.i4.s 
short s1 = 0x11; // ldc.i4.s (same as for int32)
short s2 = 0x22; // ldc.i4.s 

s1 == i1 // ceq
i1 == s1 // ceq
i1 == i2 // ceq
s1 == s2 // ceq
// no difference between int and short for those 4 cases,
// anyway the shorts are pushed as integers.

i1.Equals(i2) // calls System.Int32.Equals
s1.Equals(s2) // calls System.Int16.Equals
i1.Equals(s1) // calls System.Int32.Equals: s1 is considered as an integer
// - again it was pushed as such on the stack)
s1.Equals(i1) // boxes the int32 then calls System.Int16.Equals
// - int16 has 2 Equals methods: one for in16 and one for Object.
// Casting an int32 into an int16 is not safe, so the Object overload
// must be used instead.

== ในดั้งเดิม

Console.WriteLine(age == newAge);          // true

ในการเปรียบเทียบแบบดั้งเดิม == โอเปอเรเตอร์ทำงานค่อนข้างชัดเจนใน C # มีโอเปอร์เรเตอร์ == มากมายพร้อมใช้งาน

• string == string
• int == int
• uint == uint
• ยาว == ยาว
• อื่น ๆ อีกมากมาย

ดังนั้นในกรณีนี้ไม่มีการแปลงโดยปริยายจากintไปshortแต่shortจะintเป็นไปได้ ดังนั้น newAge จะถูกแปลงเป็น int และการเปรียบเทียบเกิดขึ้นซึ่งผลตอบแทนจริงเนื่องจากทั้งสองมีค่าเท่ากัน ดังนั้นจึงเท่ากับ:

Console.WriteLine(age == (int)newAge);          // true

.Equals () ในดั้งเดิม

Console.WriteLine(newAge.Equals(age));         //false

ที่นี่เราต้องดูว่าวิธีการ Equals () คืออะไรเราเรียก Equals พร้อมกับตัวแปรชนิดสั้น ๆ ดังนั้นจึงมีความเป็นไปได้สามประการ:

• เท่ากับ (วัตถุวัตถุ) // วิธีคงที่จากวัตถุ
• เท่ากับ (วัตถุ) // วิธีเสมือนจากวัตถุ
• เท่ากับ (สั้น) // ใช้ IEquatable.Equals (สั้น)

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

bool Equals(object z)
{
  return z is short && (short)z == this;
}

ดังนั้นที่นี่สภาพได้รับการทดสอบz is shortซึ่งเป็นเท็จเนื่องจาก z เป็น int ดังนั้นมันกลับเท็จ

นี่คือรายละเอียดบทความจาก Eric Lippert