เหตุใด C # จึงไม่สามารถเปรียบเทียบประเภทของวัตถุสองชนิดด้วยกัน แต่ VB ไม่ได้

ฉันมีสองวัตถุใน C # และไม่ทราบว่าเป็นบูลีนหรือประเภทอื่น ๆ อย่างไรก็ตามเมื่อฉันพยายามเปรียบเทียบ C # เหล่านั้นล้มเหลวในการให้คำตอบที่ถูกต้อง ฉันได้ลองใช้รหัสเดียวกันกับ VB.NET แล้วและได้ทำเช่นนั้น!

ใครช่วยบอกฉันได้ว่าจะแก้ไขได้อย่างไรถ้ามีทางออก?

ค#:

object a = true;
object b = true;
object c = false;
if (a == b) c = true;
MessageBox.Show(c.ToString()); //Outputs False !!

VB.NET:

Dim a As Object = True
Dim b As Object = True
Dim c As Object = False
If (a = b) Then c = True
MessageBox.Show(c.ToString()) '// Outputs True

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

แก้ไข: ด้วยประเภทที่เกินพิกัด==คุณสามารถรับพฤติกรรมที่แตกต่าง - แต่ขึ้นอยู่กับประเภทเวลารวบรวมของการแสดงออก ตัวอย่างเช่นstringให้==(string, string):

string x = new string("foo".ToCharArray());
string y = new string("foo".ToCharArray());
Console.WriteLine(x == y); // True
Console.WriteLine((object) x == (object) y); // False

นี่คือการเปรียบเทียบครั้งแรกที่ใช้ตัวดำเนินการโอเวอร์โหลด แต่ตัวที่สองกำลังใช้การเปรียบเทียบการอ้างอิง "ค่าเริ่มต้น"

ใน VB ตัว=ดำเนินการทำงานได้มากขึ้นทั้งหมด - ไม่เพียงเทียบเท่ากับการใช้object.Equals(x, y)เนื่องจากสิ่งต่าง ๆ เช่นOption Compareมีผลต่อการเปรียบเทียบข้อความ

โดยพื้นฐานแล้วผู้ประกอบการจะไม่ทำงานในลักษณะเดียวกันและไม่ได้ตั้งใจให้ทำงานแบบเดียวกัน

นอกจากคำตอบของจอนซึ่งอธิบายด้าน C # ของสิ่งต่าง ๆ แล้วนี่คือสิ่งที่ VB ทำ:

ใน VB ด้วยOption Strict Onการเปรียบเทียบผ่านการทดสอบ= เสมอสำหรับความเท่าเทียมกันของค่าและไม่เคยสำหรับความเท่าเทียมกันอ้างอิง ในความเป็นจริงรหัสของคุณไม่ได้รวบรวมเมื่อคุณเปลี่ยนOption Strict Onเพราะไม่ได้กำหนดSystem.Object Operator=คุณควรมีตัวเลือกนี้อยู่เสมอมันจับแมลงได้อย่างมีประสิทธิภาพมากกว่าวีนัส flytrap (แม้ว่าในกรณีของคุณพฤติกรรมแบบหละหลวมนี้จะทำในสิ่งที่ถูกต้อง) ¹

ในความเป็นจริงกับOption Strict OnVB ทำงานได้แม้จะเข้มงวดกว่า C #: ใน C # a == b ทั้งเรียกการโทรSomeType.operator==(a, b)หรือถ้าไม่มีอยู่เรียกการเปรียบเทียบความเท่าเทียมกันอ้างอิง (ซึ่งเทียบเท่ากับการโทรobject.ReferenceEquals(a, b))

ใน VB ในอีกทางหนึ่งการเปรียบเทียบa = b จะเรียกใช้ตัวดำเนินการความเสมอภาคเสมอ ²หากคุณต้องการใช้การเปรียบเทียบความเท่าเทียมกันของการอ้างอิงคุณต้องใช้a Is b(ซึ่งก็คือเหมือนกันอีกครั้งObject.ReferenceEquals(a, b))

¹⁾ต่อไปนี้เป็นข้อบ่งชี้ที่ดีว่าทำไมใช้Option Strict Offเป็นความคิดที่ไม่ดี: ฉัน VB.NET มือเกือบทศวรรษที่ผ่านมาจากก่อนที่จะปล่อยอย่างเป็นทางการ .NET จนกระทั่งไม่กี่ปีที่ผ่านมาและฉันได้อย่างคิดว่าสิ่งที่ทำกับa = b Option Strict Offมันเปรียบเทียบความเท่าเทียมกันบางอย่าง แต่เกิดอะไรขึ้นกันแน่และทำไมไม่มีความคิด มันซับซ้อนกว่าdynamicฟีเจอร์ของ C # แต่เนื่องจาก (ขึ้นอยู่กับ API ที่มีเอกสารครบถ้วน) นี่คือสิ่งที่ MSDN พูดว่า:

เนื่องจากOption Strict Onมีการพิมพ์ที่รัดกุมป้องกันการแปลงชนิดโดยไม่ตั้งใจกับการสูญหายของข้อมูลปิดการเชื่อมโยงช้าและปรับปรุงประสิทธิภาพจึงแนะนำให้ใช้อย่างยิ่ง

²⁾จอนได้กล่าวถึงข้อยกเว้นหนึ่งข้อว่าสตริงที่การเปรียบเทียบความเท่าเทียมกันทำอะไรมากกว่านี้เพื่อเหตุผลด้านความเข้ากันได้ย้อนหลัง

อินสแตนซ์ของวัตถุจะไม่ถูกเปรียบเทียบกับโอเปอเรเตอร์ "==" คุณควรใช้วิธีการ "เท่ากับ" ด้วยตัวดำเนินการ "==" กำลังเปรียบเทียบการอ้างอิงไม่ใช่วัตถุ

ลองสิ่งนี้:

public class MyObject
{
    public MyObject(String v)
    {
        Value = v;
    }
    public String Value { get; set; }
}

MyObject a = new MyObject("a");
MyObject b = new MyObject("a");
if(a==b){
    Debug.WriteLine("a reference is equal to b reference");
}else{
    Debug.WriteLine("a reference is not equal to b reference");
}
if (a.Equals(b)) {
    Debug.WriteLine("a object is equal to b object");
} else {
    Debug.WriteLine("a object is not equal to b object");
}

ผล:

a reference is not equal to b reference
a object is not equal to b object

ตอนนี้ลองทำสิ่งนี้:

public class MyObject
{
    public MyObject(String v)
    {
        Value = v;
    }
    public String Value { get; set; }

    public bool Equals(MyObject o)
    {
        return (Value.CompareTo(o.Value)==0);
    }
}
MyObject a = new MyObject("a");
MyObject b = new MyObject("a");
if(a==b){
    Debug.WriteLine("a reference is equal to b reference");
}else{
    Debug.WriteLine("a reference is not equal to b reference");
}
if (a.Equals(b)) {
    Debug.WriteLine("a object is equal to b object");
} else {
    Debug.WriteLine("a object is not equal to b object");
}

ผล:

a reference is not equal to b reference
a object is equal to b object

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

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

สิ่งนี้แตกต่างจาก VB ใน VB นั้นไม่ได้กำหนดการใช้งานในเวลารวบรวม มันจะรอจนกระทั่งรันไทม์และตรวจสอบพารามิเตอร์ทั้งสองที่ได้รับเพื่อพิจารณา==ว่าควรใช้การปฏิบัติงานของโอเปอเรเตอร์ใด

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

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