ทำไม C # ห้ามประเภทแอตทริบิวต์ทั่วไป?

สิ่งนี้ทำให้เกิดข้อยกเว้นเวลาคอมไพล์:

public sealed class ValidatesAttribute<T> : Attribute
{

}

[Validates<string>]
public static class StringValidation
{

}

ฉันรู้ว่า C # ไม่รองรับคุณสมบัติทั่วไป อย่างไรก็ตามหลังจาก Googling มากฉันไม่สามารถหาเหตุผลได้

ไม่มีใครรู้ว่าทำไมประเภททั่วไปไม่สามารถได้มาจากAttributeไหน? ทฤษฎีใด ๆ

ฉันไม่สามารถตอบได้ว่าทำไมถึงไม่มี แต่ฉันสามารถยืนยันได้ว่ามันไม่ใช่ปัญหา CLI ข้อมูลจำเพาะ CLI ไม่ได้กล่าวถึง (เท่าที่ฉันเห็น) และหากคุณใช้ IL โดยตรงคุณสามารถสร้างแอตทริบิวต์ทั่วไปได้ ส่วนหนึ่งของสเปค C # 3 ที่เรย์แบน - ส่วน 10.1.4 "ข้อมูลจำเพาะของคลาสพื้นฐาน" ไม่ได้ให้เหตุผลใด ๆ

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

สำเนาข้อกำหนด C # 3 ที่มีหมายเหตุประกอบไว้ของฉันควรมาถึงในวันพรุ่งนี้ ... ฉันจะดูว่าให้ข้อมูลเพิ่มเติมหรือไม่ อย่างไรก็ตามมันเป็นการตัดสินใจทางภาษามากกว่าการใช้งานจริง

แก้ไข: คำตอบจาก Eric Lippert (ถอดความ): ไม่มีเหตุผลเฉพาะยกเว้นเพื่อหลีกเลี่ยงความซับซ้อนในทั้งภาษาและคอมไพเลอร์สำหรับกรณีการใช้งานซึ่งไม่ได้เพิ่มคุณค่ามากนัก

แอตทริบิวต์ตกแต่งคลาสที่รวบรวมเวลา แต่คลาสทั่วไปไม่ได้รับข้อมูลประเภทสุดท้ายจนกระทั่งรันไทม์ เนื่องจากแอตทริบิวต์สามารถส่งผลกระทบต่อการรวบรวมจึงต้องเป็น "สมบูรณ์" ในเวลารวบรวม

ดูบทความ MSDN นี้สำหรับข้อมูลเพิ่มเติม

ฉันไม่รู้ว่าทำไมมันถึงไม่ได้รับอนุญาต แต่นี่เป็นวิธีแก้ปัญหาหนึ่งที่เป็นไปได้

[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
{
    ....
}

นี่ไม่ใช่เรื่องทั่วไปอย่างแท้จริงและคุณยังคงต้องเขียน class attribute เฉพาะต่อประเภท แต่คุณอาจจะสามารถใช้อินเตอร์เฟสพื้นฐานทั่วไปในการเขียนโค้ดแบบป้องกันได้เล็กน้อยเขียนรหัสน้อยกว่าที่ต้องการรับผลประโยชน์จาก polymorphism เป็นต้น

//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
{

}

นี่เป็นคำถามที่ดีมาก จากประสบการณ์ของผมที่มีคุณลักษณะที่ผมคิดว่าข้อ จำกัด อยู่ในสถานที่เพราะเมื่อสะท้อนให้เห็นถึงแอตทริบิวต์มันจะสร้างเงื่อนไขในการที่คุณจะต้องมีการตรวจสอบทุกประเภทพีชคณิตเป็นไปได้: typeof(Validates<string>), typeof(Validates<SomeCustomType>)ฯลฯ ...

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

บางทีคลาสการตรวจสอบที่ใช้ในSomeCustomValidationDelegateหรือISomeCustomValidatorเป็นพารามิเตอร์อาจเป็นวิธีที่ดีกว่า

นี่คือไม่ได้เป็นคุณสมบัติ # ภาษา C แต่มีการอภิปรายมากอย่างเป็นทางการใน C # repo

จากบันทึกย่อการประชุมบางส่วน :

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

เราจำเป็นต้องมีกลไกในการทำความเข้าใจกับรันไทม์เป้าหมายที่ทำงาน เราต้องการสิ่งนั้นในหลาย ๆ สิ่งและกำลังมองหาสิ่งนั้นอยู่ ก่อนหน้านั้นเราไม่สามารถรับมันได้

ผู้สมัครรุ่น C # ที่สำคัญถ้าเราสามารถสร้างจำนวนรันไทม์ที่เพียงพอให้จัดการได้

วิธีแก้ปัญหาของฉันคืออะไรเช่นนี้:

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