C # genel öznitelik türlerini neden yasaklıyor?

Bu, derleme zamanı özel durumuna neden olur:

public sealed class ValidatesAttribute<T> : Attribute
{

}

[Validates<string>]
public static class StringValidation
{

}

C # genel öznitelikleri desteklemediğini anlıyorum. Ancak, çok fazla Google'dan sonra nedenini bulamıyorum.

Jenerik tiplerin neden türetilemeyeceğini bilen var mı Attribute? Herhangi bir teori var mı?

Eh, müsait değil neden cevap veremez ama olabilir bir CLI sorun değil emin olun. CLI spesifikasyonu bundan bahsetmiyor (görebildiğim kadarıyla) ve IL'yi doğrudan kullanırsanız genel bir özellik oluşturabilirsiniz. C # 3 spesifikasyonunun onu yasaklayan kısmı - bölüm 10.1.4 "Sınıf tabanı spesifikasyonu" herhangi bir gerekçe vermiyor.

Ek açıklamalı ECMA C # 2 spesifikasyonu, izin verilmeyenlere bir örnek sunmasına rağmen yararlı bilgiler vermez.

Açıklamalı C # 3 spec kopyam yarın gelmeli ... Bunun daha fazla bilgi verip vermediğini göreceğim. Her neyse, kesinlikle bir çalışma zamanı yerine bir dil kararı.

DÜZENLEME: Eric Lippert'in cevabı (başka sözcüklerle yazılmış): Çok fazla değer katmayan bir kullanım durumu için hem dilde hem de derleyicide karmaşıklıktan kaçınmak için özel bir neden yoktur.

Bir öznitelik, derleme zamanında bir sınıfı süslerse de, genel bir sınıf çalışma zamanına kadar son tür bilgilerini almaz. Öznitelik derlemeyi etkileyebileceğinden, derleme zamanında "tam" olmalıdır.

Daha fazla bilgi için bu MSDN makalesine bakın .

Neden izin verilmediğini bilmiyorum, ama bu olası bir çözüm

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

Bu gerçekten genel değildir ve yine de tür başına belirli bir öznitelik sınıfı yazmanız gerekir, ancak biraz savunmacı olarak kodlamak, aksi halde gerekenden daha az kod yazmak, polimorfizmden faydalanmak vb. İçin genel bir taban arabirimi kullanabilirsiniz.

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

}

Bu çok iyi bir soru. Özelliklere sahip Tecrübelerime göre, ben bir özelliğin üzerine yansıtan zaman mümkün olan bütün tip permütasyon için kontrol etmesi gerekir hangi bir koşul oluşturacak çünkü kısıt yerinde olduğunu düşünüyorum: typeof(Validates<string>), typeof(Validates<SomeCustomType>), vs ...

Kanımca, türe bağlı olarak özel bir doğrulama gerekiyorsa, bir özellik en iyi yaklaşım olmayabilir.

Belki bir SomeCustomValidationDelegateveya ISomeCustomValidatora parametresini alan bir doğrulama sınıfı daha iyi bir yaklaşım olabilir.

Bu şu anda bir C # dili özelliği değil, ancak resmi C # dili repo hakkında çok fazla tartışma var .

Gönderen bazı toplantı notları :

Her ne kadar bu prensipte çalışsa da, çalışma zamanının çoğu versiyonunda hatalar vardır, böylece düzgün çalışmaz (asla egzersiz yapılmadı).

Hangi hedef çalışma zamanının üzerinde çalıştığını anlamak için bir mekanizmaya ihtiyacımız var. Birçok şey için buna ihtiyacımız var ve şu anda buna bakıyoruz. O zamana kadar kabul edemeyiz.

Büyük bir C # sürümü için aday, eğer yeterli sayıda çalışma zamanı sürümü ile başa çıkabilirsek.

Benim geçici çözüm şöyle bir şey:

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