Tại sao C # cấm các loại thuộc tính chung?

Điều này gây ra ngoại lệ thời gian biên dịch:

public sealed class ValidatesAttribute<T> : Attribute
{

}

[Validates<string>]
public static class StringValidation
{

}

Tôi nhận ra C # không hỗ trợ các thuộc tính chung. Tuy nhiên, sau nhiều lần Googling, tôi dường như không thể tìm thấy lý do.

Có ai biết tại sao các loại chung chung không thể xuất phát từ Attribute? Bất kỳ lý thuyết?

Chà, tôi không thể trả lời tại sao nó không có sẵn, nhưng tôi có thể xác nhận rằng đó không phải là vấn đề CLI. Thông số CLI không đề cập đến nó (theo như tôi có thể thấy) và nếu bạn sử dụng IL trực tiếp, bạn có thể tạo một thuộc tính chung. Một phần của thông số C # 3 cấm nó - phần 10.1.4 "Đặc tả cơ sở lớp" không đưa ra bất kỳ lời biện minh nào.

Thông số ECMA C # 2 được chú thích cũng không cung cấp bất kỳ thông tin hữu ích nào, mặc dù nó cung cấp một ví dụ về những gì không được phép.

Bản sao của thông số C # 3 được chú thích sẽ xuất hiện vào ngày mai ... Tôi sẽ xem liệu điều đó có cung cấp thêm thông tin nào không. Dù sao, đó chắc chắn là một quyết định ngôn ngữ chứ không phải là thời gian chạy.

EDIT: Trả lời từ Eric Lippert (paraphrased): không có lý do cụ thể, ngoại trừ để tránh sự phức tạp trong cả ngôn ngữ và trình biên dịch cho một trường hợp sử dụng không thêm nhiều giá trị.

Một thuộc tính trang trí một lớp tại thời gian biên dịch, nhưng một lớp chung không nhận được thông tin loại cuối cùng cho đến khi thời gian chạy. Vì thuộc tính có thể ảnh hưởng đến quá trình biên dịch, nó phải "hoàn thành" tại thời điểm biên dịch.

Xem bài viết MSDN này để biết thêm thông tin.

Tôi không biết tại sao nó không được phép, nhưng đây là một cách giải quyết có thể

[AttributeUsage(AttributeTargets.Class)]
public class ClassDescriptionAttribute : Attribute
{
    public ClassDescriptionAttribute(Type KeyDataType)
    {
        _KeyDataType = KeyDataType;
    }

    public Type KeyDataType
    {
        get { return _KeyDataType; }
    }
    private Type _KeyDataType;
}


[ClassDescriptionAttribute(typeof(string))]
class Program
{
    ....
}

Điều này không thực sự chung chung và bạn vẫn phải viết lớp thuộc tính cụ thể cho mỗi loại, nhưng bạn có thể sử dụng giao diện cơ sở chung để mã hóa một chút phòng thủ, viết mã ít hơn so với yêu cầu khác, nhận được lợi ích của đa hình, v.v.

//an interface which means it can't have its own implementation. 
//You might need to use extension methods on this interface for that.
public interface ValidatesAttribute<T>
{
    T Value { get; } //or whatever that is
    bool IsValid { get; } //etc
}

public class ValidatesStringAttribute : Attribute, ValidatesAttribute<string>
{
    //...
}
public class ValidatesIntAttribute : Attribute, ValidatesAttribute<int>
{
    //...
}

[ValidatesString]
public static class StringValidation
{

}
[ValidatesInt]
public static class IntValidation
{

}

Đây là một câu hỏi rất hay. Theo kinh nghiệm của tôi với các thuộc tính, tôi nghĩ rằng các hạn chế được đặt ra bởi vì khi suy niệm về một thuộc tính nó sẽ tạo ra một tình trạng mà trong đó bạn sẽ phải kiểm tra tất cả các hoán vị loại thể: typeof(Validates<string>), typeof(Validates<SomeCustomType>), vv ...

Theo tôi, nếu yêu cầu xác thực tùy chỉnh tùy thuộc vào loại, một thuộc tính có thể không phải là cách tiếp cận tốt nhất.

Có lẽ một lớp xác nhận lấy một SomeCustomValidationDelegatehoặc ISomeCustomValidatormột tham số sẽ là một cách tiếp cận tốt hơn.

Đây hiện không phải là một tính năng ngôn ngữ C #, tuy nhiên có nhiều thảo luận về repo ngôn ngữ C # chính thức .

Từ một số ghi chú cuộc họp :

Mặc dù điều này sẽ hoạt động trên nguyên tắc, có một số lỗi trong hầu hết các phiên bản của thời gian chạy để nó không hoạt động chính xác (nó không bao giờ được thực hiện).

Chúng ta cần một cơ chế để hiểu thời gian chạy đích mà nó hoạt động. Chúng tôi cần điều đó cho nhiều thứ, và hiện đang xem xét điều đó. Cho đến lúc đó, chúng tôi không thể lấy nó.

Ứng cử viên cho một phiên bản C # chính, nếu chúng tôi có thể tạo đủ số lượng phiên bản thời gian chạy đối phó với nó.

Cách giải quyết của tôi là một cái gì đó như thế này:

public class DistinctType1IdValidation : ValidationAttribute
{
    private readonly DistinctValidator<Type1> validator;

    public DistinctIdValidation()
    {
        validator = new DistinctValidator<Type1>(x=>x.Id);
    }

    public override bool IsValid(object value)
    {
        return validator.IsValid(value);
    }
}

public class DistinctType2NameValidation : ValidationAttribute
{
    private readonly DistinctValidator<Type2> validator;

    public DistinctType2NameValidation()
    {
        validator = new DistinctValidator<Type2>(x=>x.Name);
    }

    public override bool IsValid(object value)
    {
        return validator.IsValid(value);
    }
}

...
[DataMember, DistinctType1IdValidation ]
public Type1[] Items { get; set; }

[DataMember, DistinctType2NameValidation ]
public Type2[] Items { get; set; }