Tại sao tôi có thể gán 0,0 cho các giá trị liệt kê mà không phải 1,0

Chỉ vì tò mò: tại sao tôi có thể gán 0,0 cho một biến thuộc kiểu liệt kê, mà không phải 1,0? Hãy xem đoạn mã sau:

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

Tôi nghĩ rằng chuyển đổi giữa các kiểu số và giá trị liệt kê chỉ được phép thông qua phôi? Đó là tôi có thể viết Foo value2 = (Foo) 1.0;để dòng 2 trong Maincó thể biên dịch. Tại sao có một ngoại lệ cho giá trị 0.0trong C #?

Đó là một lỗi mà bạn có thể sử dụng 0.0. Trình biên dịch xử lý ngầm tất cả các biểu thức hằng có giá trị bằng 0 chỉ bằng 0.

Bây giờ, nó là đúng cho trình biên dịch cho phép một chuyển đổi ngầm từ một hằng số intbiểu hiện của từ 0 đến enum của bạn theo mục 6.1.3 của 5 đặc điểm kỹ thuật C #:

Một chuyển đổi kiểu liệt kê ngầm cho phép chuyển đổi số thập phân-số nguyên-chữ 0 thành bất kỳ kiểu enum nào và thành bất kỳ kiểu nullable nào có kiểu cơ bản là kiểu enum. Trong trường hợp thứ hai, chuyển đổi được đánh giá bằng cách chuyển đổi thành kiểu enum bên dưới và bao bọc kết quả (§4.1.10).

Tôi đã nói chuyện với nhóm C # về điều này trước đây: họ muốn loại bỏ chuyển đổi ngẫu nhiên từ giá trị 0,0 (và thực tế là 0,0m và 0,0f) thành giá trị enum, nhưng thật không may, tôi thu thập nó đã làm hỏng quá nhiều mã - mặc dù nó không bao giờ được cho phép ngay từ đầu.

Mono mcsbiên dịch cấm tất cả các chuyển đổi dấu chấm động, mặc dù nó không cho phép:

const int Zero = 0;
...

SomeEnum x = Zero;

mặc dù thực tế đó Zerolà một biểu thức hằng nhưng không phải là một chữ số thập phân-số nguyên.

Tôi sẽ không ngạc nhiên khi thấy đặc điểm kỹ thuật C # thay đổi trong tương lai để cho phép bất kỳ biểu thức hằng số nguyên nào có giá trị 0 (tức là bắt chước mcs), nhưng tôi sẽ không mong đợi các chuyển đổi dấu phẩy động sẽ chính thức đúng. (Tất nhiên, tôi đã sai trước đây khi dự đoán tương lai của C # ...)

Câu trả lời của Jon là đúng. Tôi sẽ thêm vào nó những điểm sau đây.

• Tôi đã gây ra lỗi ngớ ngẩn và đáng xấu hổ này. Nhieu loi xin loi.

• Lỗi do tôi hiểu sai ngữ nghĩa của một vị từ "biểu thức là số không" trong trình biên dịch; Tôi tin rằng nó chỉ đang kiểm tra sự bình đẳng của số nguyên, trong khi thực tế nó đang kiểm tra nhiều thứ hơn dọc theo dòng "đây có phải là giá trị mặc định của kiểu này không?" Trên thực tế, trong một phiên bản trước của lỗi, thực sự có thể gán giá trị mặc định của bất kỳ loại nào cho một enum! Bây giờ nó chỉ là giá trị mặc định của số. (Bài học: Đặt tên cho các vị từ trợ giúp của bạn một cách cẩn thận.)

• Hành vi tôi đang cố gắng thực hiện mà tôi đã nhầm lẫn trên thực tế là một cách giải quyết cho một lỗi hơi khác. Bạn có thể đọc toàn bộ câu chuyện khủng khiếp tại đây: https://docs.microsoft.com/en-us/archive/blogs/ericlippert/the-root-of-all-evil-part-one và https://docs.microsoft .com / en-us / archive / blogs / ericlippert / the-root-of-all-evil-part-hai (Bài học: Rất dễ tạo ra các lỗi mới tồi tệ hơn trong khi sửa các lỗi cũ.)

• Nhóm C # quyết định che giấu hành vi lỗi này thay vì sửa chữa nó vì nguy cơ phá vỡ mã hiện có mà không có lợi ích hấp dẫn là quá cao. (Bài học: làm đúng ngay lần đầu tiên!)

• Có thể tìm thấy mã tôi đã viết trong Roslyn để duy trì hành vi này trong phương thức IsConstantNumericZerotại https://github.com/dotnet/roslyn/blob/master/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs - xem nó để biết thêm chi tiết về hành vi chính xác của Roslyn. Tôi đã viết gần như tất cả mã trong thư mục Chuyển đổi; Tôi khuyến khích bạn đọc tất cả vì có rất nhiều sự thật thú vị về cách C # khác biệt với đặc điểm kỹ thuật trong các nhận xét. Tôi đã trang trí từng vi phạm cụ thể để dễ dàng tìm thấy chúng.

Một điểm quan tâm nữa: C # cũng cho phép bất kỳ giá trị enum nào được sử dụng trong trình khởi tạo enum bất kể độ không của nó:

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

Thông số kỹ thuật hơi mơ hồ về việc liệu điều này có hợp pháp hay không, nhưng một lần nữa, vì điều này đã có trong trình biên dịch từ lâu, nên các trình biên dịch mới có khả năng duy trì hành vi.

Các phép liệt kê trong C # là các giá trị tích phân theo định nghĩa. Để nhất quán, C # không nên chấp nhận một trong hai phép gán này, nhưng 0.0được coi là tích phân 0. Đây có thể là một phần giữ lại từ C, nơi chữ 0được xử lý đặc biệt và về cơ bản có thể nhận bất kỳ kiểu nào đã cho - số nguyên, số dấu phẩy động, con trỏ null… bạn đặt tên cho nó.

enum thực sự nhằm mục đích (trong tất cả các ngôn ngữ hỗ trợ nó) là một cách để làm việc với các chuỗi (nhãn) có ý nghĩa và duy nhất chứ không phải là một giá trị số. Vì vậy, trong ví dụ của bạn, bạn chỉ nên sử dụng Bar và Baz khi xử lý kiểu dữ liệu liệt kê Foo . Bạn không bao giờ nên sử dụng (so sánh hoặc gán) một số nguyên, mặc dù nhiều trình biên dịch sẽ cho phép bạn sử dụng nó (enum thường là số nguyên bên trong) và trong trường hợp này, 0.0 được trình biên dịch coi là 0 một cách bất cẩn.

Về mặt khái niệm, sẽ ổn nếu thêm một số nguyên n vào một giá trị được liệt kê, để lấy n giá trị xuống dòng, hoặc lấy val2 - val1 để xem chúng cách nhau bao xa, nhưng trừ khi đặc tả ngôn ngữ cho phép rõ ràng điều này, tôi 'd tránh nó. (Hãy nghĩ về một giá trị được liệt kê giống như một con trỏ C, theo những cách bạn có thể sử dụng nó.) Không có lý do gì mà không thể triển khai các giá trị cộng với các số dấu phẩy động và một số gia cố định giữa chúng, nhưng tôi chưa nghe nói về điều này đang được thực hiện bằng bất kỳ ngôn ngữ nào.