Por que o C # proíbe tipos de atributos genéricos?

Isso causa uma exceção em tempo de compilação:

public sealed class ValidatesAttribute<T> : Attribute
{

}

[Validates<string>]
public static class StringValidation
{

}

Sei que o C # não suporta atributos genéricos. No entanto, depois de muito pesquisar no Google, parece que não consigo encontrar o motivo.

Alguém sabe por que os tipos genéricos não podem derivar Attribute? Alguma teoria?

Bem, não sei responder por que não está disponível, mas posso confirmar que não é um problema de CLI. A especificação da CLI não a menciona (até onde posso ver) e, se você usar o IL diretamente, poderá criar um atributo genérico. A parte da especificação do C # 3 que a proíbe - seção 10.1.4 "Especificação básica da classe" não fornece nenhuma justificativa.

A especificação ECMA C # 2 anotada também não fornece informações úteis, embora forneça um exemplo do que não é permitido.

Minha cópia da especificação C # 3 anotada deve chegar amanhã ... Vou ver se isso fornece mais informações. Enfim, é definitivamente uma decisão de idioma, e não de execução.

EDIT: Resposta de Eric Lippert (parafraseado): nenhum motivo específico, exceto para evitar complexidade no idioma e no compilador para um caso de uso que não agrega muito valor.

Um atributo decora uma classe no tempo de compilação, mas uma classe genérica não recebe suas informações de tipo final até o tempo de execução. Como o atributo pode afetar a compilação, ele deve estar "completo" no momento da compilação.

Consulte este artigo do MSDN para obter mais informações.

Não sei por que não é permitido, mas esta é uma solução possível

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

Isso não é verdadeiramente genérico e você ainda precisa escrever uma classe de atributo específica por tipo, mas pode usar uma interface básica genérica para codificar um pouco defensivamente, escrever um código menor do que o necessário, obter benefícios do polimorfismo etc.

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

}

Esta é uma pergunta muito boa. Na minha experiência com atributos, acho que a restrição está em vigor porque ao refletir sobre um atributo que iria criar uma condição em que você teria que verificar todas as permutações de tipos possíveis: typeof(Validates<string>), typeof(Validates<SomeCustomType>), etc ...

Na minha opinião, se uma validação personalizada for necessária, dependendo do tipo, um atributo pode não ser a melhor abordagem.

Talvez uma classe de validação que aceite um SomeCustomValidationDelegateou um ISomeCustomValidatorcomo parâmetro seja uma abordagem melhor.

No momento, esse não é um recurso do idioma C #, mas há muita discussão sobre o repositório oficial do idioma C # .

De algumas notas da reunião :

Mesmo que isso funcione em princípio, existem erros na maioria das versões do tempo de execução, para que não funcionem corretamente (nunca foram exercidos).

Precisamos de um mecanismo para entender em qual tempo de execução de destino ele trabalha. Precisamos disso para muitas coisas, e atualmente estamos analisando isso. Até lá, não podemos aguentar.

Candidato a uma versão principal do C #, se conseguirmos lidar com um número suficiente de versões de tempo de execução.

Minha solução alternativa é algo como isto:

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