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

Powoduje to wyjątek czasu kompilacji:

public sealed class ValidatesAttribute<T> : Attribute
{

}

[Validates<string>]
public static class StringValidation
{

}

Wiem, że C # nie obsługuje atrybutów ogólnych. Jednak po długim Googlingu nie mogę znaleźć powodu.

Czy ktoś wie, dlaczego typy ogólne nie mogą pochodzić Attribute? Jakieś teorie?

Cóż, nie mogę odpowiedzieć, dlaczego nie jest dostępny, ale może potwierdzić, że to nie jest kwestia CLI. Specyfikacja CLI nie wspomina o tym (o ile widzę) i jeśli używasz IL bezpośrednio, możesz utworzyć atrybut ogólny. Część specyfikacji C # 3, która ją zakazuje - sekcja 10.1.4 „Podstawowa specyfikacja klasy” nie daje żadnego uzasadnienia.

Adnotacja specyfikacji ECMA C # 2 również nie zawiera żadnych pomocnych informacji, chociaż stanowi przykład tego, co jest niedozwolone.

Moja kopia specyfikacji C # 3 z adnotacjami powinna przyjechać jutro ... Zobaczę, czy to da więcej informacji. W każdym razie zdecydowanie jest to decyzja językowa, a nie decyzja w czasie wykonywania.

EDYCJA: Odpowiedź Erica Lipperta (sparafrazowana): bez konkretnego powodu, z wyjątkiem uniknięcia złożoności zarówno w języku, jak i kompilatorze dla przypadku użycia, który nie wnosi dużej wartości.

Atrybut ozdabia klasę w czasie kompilacji, ale klasa ogólna nie otrzymuje informacji o ostatecznym typie do czasu uruchomienia. Ponieważ atrybut może wpływać na kompilację, musi być „kompletny” w czasie kompilacji.

Więcej informacji można znaleźć w tym artykule MSDN .

Nie wiem, dlaczego jest to niedozwolone, ale jest to jedno z możliwych obejść

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

Nie jest to naprawdę ogólne i nadal musisz napisać konkretną klasę atrybutów dla każdego typu, ale możesz być w stanie użyć ogólnego interfejsu podstawowego, aby trochę defensywnie kodować, pisać 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 jest bardzo dobre pytanie. Z mojego doświadczenia z atrybutami, myślę, że ograniczenie jest na miejscu, bo kiedy zastanawia się nad atrybutem byłoby stworzyć warunki, w których będzie trzeba sprawdzić dla wszystkich możliwych permutacji typu: typeof(Validates<string>),typeof(Validates<SomeCustomType>) , etc ...

Moim zdaniem, jeśli wymagane jest niestandardowe sprawdzenie poprawności w zależności od typu, atrybut może nie być najlepszym podejściem.

Być może lepszym podejściem byłaby klasa walidacyjna, która przyjmuje parametr a SomeCustomValidationDelegatelub a ISomeCustomValidatorjako parametr.

Obecnie nie jest to funkcja języka C #, jednak wiele dyskusji dotyczy oficjalnego repozytorium języka C # .

Z niektórych notatek ze spotkania :

Mimo że działałoby to w zasadzie, w większości wersji środowiska uruchomieniowego występują błędy, przez co nie działałby poprawnie (nigdy nie został wykorzystany).

Potrzebujemy mechanizmu, aby zrozumieć, na jakim docelowym środowisku wykonawczym działa. Potrzebujemy tego do wielu rzeczy i obecnie na to patrzymy. Do tego czasu nie możemy tego znieść.

Kandydat na główną wersję C #, jeśli uda nam się poradzić sobie z wystarczającą liczbą wersji środowiska wykonawczego.

Moje obejście jest mniej więcej 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; }