Dlaczego C# zabrania generycznych typów atrybutów?

Atrybut dekoruje klasę podczas kompilacji, ale Klasa generyczna nie otrzymuje informacji o końcowym typie do czasu uruchomienia. Ponieważ atrybut może wpływać na kompilację, musi być "kompletny" w czasie kompilacji.

Zobacz ten artykuł MSDN Aby uzyskać więcej informacji.

Nie wiem, dlaczego nie jest to dozwolone, ale jest to możliwe obejście

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

To nie jest tak naprawdę ogólne i nadal musisz napisać specyficzną klasę atrybutów dla typu, ale możesz być w stanie użyć ogólnego interfejsu bazowego do kodowania trochę defensywnie, napisać mniejszy Kod niż jest to wymagane, uzyskać korzyści z polimorfizmu itp.

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

}

To bardzo dobre pytanie. Z mojego doświadczenia z atrybutami, myślę, że ograniczenie jest na miejscu, ponieważ rozważając atrybut stworzyłby warunek, w którym musiałbyś sprawdzić wszystkie możliwe permutacje typu: typeof(Validates<string>), typeof(Validates<SomeCustomType>), itd...

Moim zdaniem, jeśli Walidacja niestandardowa jest wymagana w zależności od typu, atrybut może nie być najlepszym podejściem.

Być może Klasa walidacji, która przyjmuje SomeCustomValidationDelegate lub ISomeCustomValidator jako parametr, byłaby lepsza podejdźcie.

Moje obejście Jest Takie:

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