Perché C # proibisce i tipi di attributi generici?

Ciò provoca un'eccezione durante la compilazione:

public sealed class ValidatesAttribute<T> : Attribute
{

}

[Validates<string>]
public static class StringValidation
{

}

Mi rendo conto che C # non supporta gli attributi generici. Tuttavia, dopo molto googling, non riesco a trovare il motivo.

Qualcuno sa perché i tipi generici non possono derivare Attribute? Qualche teoria?

Bene, non posso rispondere perché non è disponibile, ma posso confermare che non si tratta di un problema con la CLI. Le specifiche CLI non lo menzionano (per quanto posso vedere) e se si utilizza IL direttamente è possibile creare un attributo generico. La parte della specifica C # 3 che la vieta - la sezione 10.1.4 "Specifica di base della classe" non fornisce alcuna giustificazione.

Le specifiche annotate ECMA C # 2 non forniscono neppure informazioni utili, sebbene forniscano un esempio di ciò che non è consentito.

La mia copia delle specifiche C # 3 con annotazioni dovrebbe arrivare domani ... Vedrò se questo fornisce ulteriori informazioni. Ad ogni modo, è sicuramente una decisione linguistica piuttosto che runtime.

EDIT: Risposta di Eric Lippert (parafrasato): nessun motivo particolare, se non per evitare complessità sia nel linguaggio che nel compilatore per un caso d'uso che non aggiunge molto valore.

Un attributo decora una classe in fase di compilazione, ma una classe generica non riceve le informazioni sul tipo finale fino al runtime. Poiché l'attributo può influire sulla compilazione, deve essere "completo" al momento della compilazione.

Vedi questo articolo MSDN per ulteriori informazioni.

Non so perché non sia permesso, ma questa è una possibile soluzione alternativa

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

Questo non è veramente generico e devi ancora scrivere una specifica classe di attributi per tipo, ma potresti essere in grado di utilizzare un'interfaccia di base generica per codificare un po 'sulla difensiva, scrivere un codice minore di quanto altrimenti richiesto, ottenere benefici del polimorfismo ecc.

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

}

Questa è un'ottima domanda Nella mia esperienza con gli attributi, credo che il vincolo è a posto, perché quando riflettendo su un attributo si creerebbe una condizione in cui si dovrà verificare la presenza di tutte le possibili permutazioni di tipo: typeof(Validates<string>), typeof(Validates<SomeCustomType>), ecc ...

Secondo me, se è necessaria una convalida personalizzata a seconda del tipo, un attributo potrebbe non essere l'approccio migliore.

Forse una classe di validazione che accetta un SomeCustomValidationDelegateo ISomeCustomValidatorcome parametro sarebbe un approccio migliore.

Questa non è attualmente una funzionalità del linguaggio C #, tuttavia si discute molto sul repository ufficiale del linguaggio C # .

Da alcune note sulla riunione :

Anche se questo funzionerebbe in linea di principio, nella maggior parte delle versioni del runtime sono presenti bug in modo che non funzionino correttamente (non è mai stato esercitato).

Abbiamo bisogno di un meccanismo per capire su quale runtime di destinazione funziona. Ne abbiamo bisogno per molte cose e al momento lo stiamo esaminando. Fino ad allora, non possiamo prenderlo.

Candidato per una versione C # importante, se riusciamo a farne un numero sufficiente di versioni di runtime.

La mia soluzione alternativa è qualcosa del genere:

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