Mengapa saya dapat menetapkan 0,0 ke nilai pencacahan, tetapi tidak 1,0

Hanya ingin tahu: mengapa saya dapat menetapkan 0,0 ke variabel yang merupakan jenis enumerasi, tetapi tidak 1,0? Lihat kode berikut:

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
    }
}

Saya pikir konversi antara tipe numerik dan nilai enumerasi hanya diperbolehkan melalui cast? Artinya saya bisa menulis Foo value2 = (Foo) 1.0;sehingga baris 2 Maindapat dikompilasi. Mengapa ada pengecualian untuk nilai 0.0di C #?

Ini adalah bug yang dapat Anda gunakan 0.0. Kompilator secara implisit memperlakukan semua ekspresi konstan dengan nilai nol hanya sebagai 0.

Sekarang, sudah benar bagi kompilator untuk mengizinkan konversi implisit dari intekspresi konstan 0 ke enum sesuai dengan bagian 6.1.3 spesifikasi C # 5:

Konversi enumerasi implisit memungkinkan desimal-integer-literal 0 untuk dikonversi ke jenis enum dan ke jenis nullable apa pun yang jenis dasarnya adalah jenis enum. Dalam kasus terakhir, konversi dievaluasi dengan mengubah ke tipe enum yang mendasarinya dan membungkus hasilnya (§4.1.10).

Saya telah berbicara dengan tim C # tentang ini sebelumnya: mereka ingin menghapus konversi yang tidak disengaja dari 0,0 (dan memang 0,0m dan 0,0f) menjadi nilai enum, tapi sayangnya saya mengumpulkannya terlalu banyak merusak kode - meskipun itu seharusnya tidak pernah diizinkan sejak awal.

Mono mcscompiler melarang semua ini konversi floating point, meskipun tidak memungkinkan:

const int Zero = 0;
...

SomeEnum x = Zero;

meskipun faktanya itu Zeroadalah ekspresi konstan tetapi bukan desimal-integer-literal.

Saya tidak akan terkejut melihat spesifikasi C # berubah di masa depan untuk memungkinkan ekspresi konstan integer dengan nilai 0 (yaitu untuk meniru mcs), tetapi saya tidak akan mengharapkan konversi floating point secara resmi benar. (Saya pernah salah sebelumnya tentang memprediksi masa depan C #, tentu saja ...)

Jawaban Jon benar. Saya akan menambahkan poin-poin berikut.

• Saya menyebabkan serangga konyol dan memalukan ini. Banyak permintaan maaf.

• Bug ini disebabkan oleh saya yang salah memahami semantik dari predikat "ekspresi adalah nol" dalam kompilator; Saya percaya itu memeriksa hanya untuk persamaan nol integer, padahal sebenarnya itu memeriksa lebih banyak di sepanjang baris "apakah ini nilai default dari jenis ini?" Faktanya, dalam versi bug sebelumnya, sebenarnya dimungkinkan untuk menetapkan nilai default dari tipe apa pun ke enum! Sekarang hanya nilai default angka. (Pelajaran: Beri nama predikat pembantu Anda dengan hati-hati.)

• Perilaku yang saya coba terapkan yang saya buat kacau sebenarnya adalah solusi untuk bug yang sedikit berbeda. Anda dapat membaca seluruh kisah mengerikan di sini: https://docs.microsoft.com/en-us/archive/blogs/ericlippert/the-root-of-all-evil-part-one dan https://docs.microsoft .com / en-us / archive / blog / ericlippert / the-root-of-all-evil-part-two (Pelajaran: Sangat mudah untuk memperkenalkan bug baru yang lebih buruk saat memperbaiki yang lama.)

• Tim C # memutuskan untuk mengabadikan perilaku buggy ini daripada memperbaikinya karena risiko melanggar kode yang ada tanpa keuntungan yang memaksa terlalu tinggi. (Pelajaran: lakukan dengan benar untuk pertama kalinya!)

• Kode yang saya tulis di Roslyn untuk menjaga perilaku ini dapat ditemukan dalam metode IsConstantNumericZerodi https://github.com/dotnet/roslyn/blob/master/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs - lihat untuk lebih jelasnya tentang apa sebenarnya perilaku Roslyn. Saya menulis hampir semua kode di direktori Konversi; Saya mendorong Anda untuk membaca semuanya karena ada banyak fakta menarik tentang bagaimana C # menyimpang dari spesifikasi di komentar. Saya menghias masing-masing dengan PELANGGARAN SPEC agar mudah ditemukan.

Satu lagi tempat menarik: C # juga memungkinkan nilai enum apa pun untuk digunakan dalam penginisialisasi enum terlepas dari ke nolnya:

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

Spesifikasi agak tidak jelas, apakah ini harus legal atau tidak, tetapi sekali lagi, karena ini telah ada di kompiler untuk waktu yang lama, kompiler baru cenderung mempertahankan perilaku tersebut.

Pencacahan di C # adalah dengan nilai integral definisi. Untuk konsistensi, C # seharusnya tidak menerima salah satu dari tugas ini, tetapi 0.0secara diam-diam diperlakukan sebagai integral 0. Ini mungkin peninggalan dari C, di mana literal 0diperlakukan secara khusus dan pada dasarnya dapat mengambil jenis tertentu - bilangan bulat, angka floating point, pointer nol ... sebut saja.

enum benar-benar dimaksudkan (dalam semua bahasa yang mendukungnya) menjadi cara untuk bekerja dengan string yang bermakna dan unik (label) daripada nilai numerik. Jadi, dalam contoh Anda, Anda seharusnya hanya menggunakan Bar dan Baz saat berhadapan dengan tipe data enumerasi Foo . Anda tidak boleh menggunakan (bandingkan dengan, atau tetapkan) bilangan bulat, meskipun banyak kompiler akan membiarkan Anda menggunakannya (enum biasanya adalah bilangan bulat secara internal), dan dalam kasus ini, 0,0 secara sembarangan diperlakukan sebagai 0 oleh kompilator.

Secara konseptual, sebaiknya menambahkan bilangan bulat n ke nilai yang disebutkan, untuk mendapatkan nilai n lebih jauh ke bawah, atau menggunakan val2 - val1 untuk melihat seberapa jauh jaraknya, tetapi kecuali spesifikasi bahasa secara eksplisit mengizinkan ini, saya akan menghindarinya. (Pikirkan nilai yang disebutkan sebagai seperti penunjuk C, dengan cara Anda dapat menggunakannya.) Tidak ada alasan enum tidak dapat diimplementasikan dengan angka floating point, dan kenaikan tetap di antara mereka, tetapi saya belum pernah mendengarnya ini dilakukan dalam bahasa apa pun.