เหตุใดฉันจึงสามารถกำหนด 0.0 ให้กับค่าการแจงนับได้ แต่ไม่ใช่ 1.0

ด้วยความอยากรู้อยากเห็น: เหตุใดฉันจึงสามารถกำหนด 0.0 ให้กับตัวแปรที่เป็นประเภทการแจงนับ แต่ไม่ใช่ 1.0 ดูรหัสต่อไปนี้:

public enum Foo
{
    Bar,
    Baz
}

class Program
{
    static void Main()
    {
        Foo value1 = 0.0;
        Foo value2 = 1.0;   // This line does not compile
        Foo value3 = 4.2;   // This line does not compile
    }
}

ฉันคิดว่าการแปลงระหว่างประเภทตัวเลขและค่าการนับจะได้รับอนุญาตผ่านการร่ายเท่านั้น? นั่นคือฉันสามารถเขียน Foo value2 = (Foo) 1.0;เพื่อให้บรรทัด 2 ในMainคอมไพล์ได้ เหตุใดจึงมีข้อยกเว้นสำหรับค่า0.0ใน C #

เป็นบั๊กที่คุณสามารถใช้ 0.0 คอมไพเลอร์ถือว่านิพจน์คงที่ทั้งหมดโดยปริยายโดยมีค่าเป็นศูนย์เป็นเพียง 0

ตอนนี้ถูกต้องสำหรับคอมไพลเลอร์ที่อนุญาตให้มีการแปลงโดยนัยจากintนิพจน์คงที่เป็น0 เป็น enum ของคุณตามส่วน 6.1.3 ของข้อกำหนด C # 5:

การแปลงการแจงนับโดยปริยายอนุญาตให้แปลงทศนิยม - จำนวนเต็ม - ลิเทอรัล 0 เป็นชนิด enum ใด ๆ และเป็นประเภทที่ไม่สามารถระบุได้ซึ่งมีประเภทที่อยู่ภายใต้การระบุประเภท ในกรณีหลังการแปลงจะได้รับการประเมินโดยการแปลงเป็น enum-type ที่อยู่ภายใต้และตัดผลลัพธ์ (§4.1.10)

ฉันเคยพูดคุยกับทีม C # เกี่ยวกับเรื่องนี้มาก่อน: พวกเขาชอบที่จะลบการแปลงโดยไม่ได้ตั้งใจจาก 0.0 (และ 0.0m และ 0.0f) เป็นค่า enum แต่น่าเสียดายที่ฉันรวบรวมรหัสมากเกินไป - แม้ว่า ไม่ควรได้รับอนุญาตตั้งแต่แรก

mcsคอมไพเลอร์Mono ห้ามการแปลงทศนิยมเหล่านี้ทั้งหมดแม้ว่าจะอนุญาต:

const int Zero = 0;
...

SomeEnum x = Zero;

แม้ว่าZeroจะเป็นนิพจน์คงที่ แต่ไม่ใช่ทศนิยม - จำนวนเต็ม - ลิเทอรัล

ฉันคงไม่แปลกใจที่เห็นการเปลี่ยนแปลงข้อกำหนด C # ในอนาคตเพื่ออนุญาตให้นิพจน์คงที่จำนวนเต็มใด ๆ ที่มีค่าเป็น 0 (เช่นเพื่อเลียนแบบmcs) แต่ฉันไม่คาดหวังว่าการแปลงทศนิยมจะถูกต้องอย่างเป็นทางการ (ฉันเคยคิดผิดเกี่ยวกับการทำนายอนาคตของ C # แน่นอน ... )

คำตอบของจอนถูกต้อง ฉันจะเพิ่มประเด็นต่อไปนี้

• ฉันทำให้เกิดข้อผิดพลาดที่โง่และน่าอายนี้ ขอโทษมากมาย.

• จุดบกพร่องเกิดจากการที่ฉันเข้าใจความหมายของเพรดิเคต "นิพจน์เป็นศูนย์" ผิดพลาดในคอมไพเลอร์ ฉันเชื่อว่ามันกำลังตรวจสอบความเท่าเทียมกันของจำนวนเต็มศูนย์เท่านั้นเมื่อในความเป็นจริงมันกำลังตรวจสอบเพิ่มเติมตามบรรทัดของ "นี่เป็นค่าเริ่มต้นของประเภทนี้หรือไม่" ในความเป็นจริงในเวอร์ชันก่อนหน้าของบั๊กนั้นเป็นไปได้ที่จะกำหนดค่าเริ่มต้นของประเภทใด ๆ ให้กับ enum! ตอนนี้เป็นเพียงค่าเริ่มต้นของตัวเลขเท่านั้น (บทเรียน: ตั้งชื่อผู้ช่วยเหลือของคุณอย่างระมัดระวัง)

• พฤติกรรมที่ฉันพยายามนำไปใช้ที่ฉันทำผิดนั้นเป็นวิธีแก้ปัญหาสำหรับจุดบกพร่องที่แตกต่างกันเล็กน้อย คุณสามารถอ่านเรื่องราวเลวร้ายทั้งหมดได้ที่นี่: https://docs.microsoft.com/en-us/archive/blogs/ericlippert/the-root-of-all-evil-part-oneและ https://docs.microsoft .com / en-us / archive / blogs / ericlippert / the-root-of-all-evil-part-สอง (บทเรียน: การแนะนำจุดบกพร่องใหม่ที่แย่กว่าเดิมเป็นเรื่องง่ายมากในขณะที่แก้ไขข้อบกพร่องเก่า)

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

• รหัสที่ฉันเขียนใน Roslyn เพื่อรักษาพฤติกรรมนี้สามารถพบได้ในวิธีการIsConstantNumericZeroในhttps://github.com/dotnet/roslyn/blob/master/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs - ดูรายละเอียดเพิ่มเติมว่าพฤติกรรมของ Roslyn คืออะไร ฉันเขียนโค้ดเกือบทั้งหมดในไดเร็กทอรี Conversions ฉันขอแนะนำให้คุณอ่านทั้งหมดเนื่องจากมีข้อเท็จจริงที่น่าสนใจมากมายเกี่ยวกับการที่ C # แตกต่างจากข้อกำหนดในความคิดเห็น ฉันตกแต่งแต่ละชิ้นด้วย SPEC VIOLATION เพื่อให้ง่ายต่อการค้นหา

อีกหนึ่งจุดที่น่าสนใจ: C # ยังอนุญาตให้ใช้ค่า enum ใด ๆในตัวเริ่มต้น enum โดยไม่คำนึงถึงความชัดเจน:

enum E { A = 1 }
enum F { B = E.A }  // ???

ข้อมูลจำเพาะค่อนข้างคลุมเครือว่าสิ่งนี้ควรถูกกฎหมายหรือไม่ แต่อีกครั้งเนื่องจากสิ่งนี้มีอยู่ในคอมไพเลอร์เป็นเวลานานคอมไพเลอร์ใหม่จึงมีแนวโน้มที่จะคงพฤติกรรมไว้

การแจงนับใน C # มาจากค่าอินทิกรัลของนิยาม เพื่อความสอดคล้อง C # ไม่ควรยอมรับการมอบหมายอย่างใดอย่างหนึ่งเหล่านี้ แต่0.0จะถือว่าเป็นอินทิกรั0ล นี่อาจเป็นการยึดจาก C โดยที่ลิเทอรัล0ได้รับการปฏิบัติเป็นพิเศษและโดยพื้นฐานแล้วสามารถใช้ประเภทใดก็ได้ - จำนวนเต็มเลขทศนิยมตัวชี้โมฆะ ... คุณตั้งชื่อมัน

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

ตามแนวคิดแล้วควรจะเพิ่มจำนวนเต็มnให้กับค่าที่แจกแจงได้ถูกต้องเพื่อให้ได้ค่าnเพิ่มเติมลงไปในบรรทัดหรือใช้val2 - val1เพื่อดูว่าพวกมันอยู่ห่างกันแค่ไหน แต่เว้นแต่ข้อกำหนดภาษาจะอนุญาตอย่างชัดเจน หลีกเลี่ยงมัน (คิดว่าค่าที่แจกแจงเป็นเหมือนตัวชี้ C ในแบบที่คุณสามารถใช้ได้) ไม่มีเหตุผลที่ไม่สามารถใช้ enums กับตัวเลขทศนิยมและการเพิ่มที่คงที่ระหว่างค่าเหล่านี้ แต่ฉันไม่เคยได้ยิน สิ่งนี้ทำในภาษาใดก็ได้