Warum verbietet C # generische Attributtypen?

Dies führt zu einer Ausnahme bei der Kompilierung:

public sealed class ValidatesAttribute<T> : Attribute
{

}

[Validates<string>]
public static class StringValidation
{

}

Mir ist klar, dass C # keine generischen Attribute unterstützt. Nach langem Googeln kann ich den Grund jedoch nicht finden.

Weiß jemand, warum generische Typen nicht abgeleitet werden können? Attribute ? Irgendwelche Theorien?

Nun, ich kann nicht antworten, warum es nicht verfügbar ist, aber ich kann bestätigen, dass es sich nicht um ein CLI-Problem handelt. Die CLI-Spezifikation erwähnt es nicht (soweit ich sehen kann) und wenn Sie IL direkt verwenden, können Sie ein generisches Attribut erstellen. Der Teil der C # 3-Spezifikation, der dies verbietet - Abschnitt 10.1.4 "Klassenbasisspezifikation" gibt keine Rechtfertigung.

Die mit Anmerkungen versehene ECMA C # 2-Spezifikation enthält ebenfalls keine hilfreichen Informationen, obwohl sie ein Beispiel dafür enthält, was nicht zulässig ist.

Meine Kopie der kommentierten C # 3-Spezifikation sollte morgen eintreffen ... Ich werde sehen, ob das weitere Informationen liefert. Auf jeden Fall ist es definitiv eher eine Sprachentscheidung als eine Laufzeitentscheidung.

EDIT: Antwort von Eric Lippert (umschrieben): Kein besonderer Grund, außer um Komplexität sowohl in der Sprache als auch im Compiler für einen Anwendungsfall zu vermeiden, der nicht viel Wert hinzufügt.

Ein Attribut schmückt eine Klasse zur Kompilierungszeit, aber eine generische Klasse erhält ihre endgültigen Typinformationen erst zur Laufzeit. Da das Attribut die Kompilierung beeinflussen kann, muss es zur Kompilierungszeit "vollständig" sein.

Weitere Informationen finden Sie in diesem MSDN-Artikel .

Ich weiß nicht, warum es nicht erlaubt ist, aber dies ist eine mögliche Problemumgehung

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

Dies ist nicht wirklich generisch und Sie müssen immer noch eine bestimmte Attributklasse pro Typ schreiben, aber Sie können möglicherweise eine generische Basisschnittstelle verwenden, um ein wenig defensiv zu codieren, weniger Code als sonst erforderlich zu schreiben, Vorteile des Polymorphismus zu erzielen usw.

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

}

Das ist eine sehr gute Frage. Nach meiner Erfahrung mit Attributen, ich denke , die Einschränkung vorhanden ist , weil , wenn auf einem Attribut reflektieren würde es einen Zustand schaffen , in dem Sie für alle mögliche Typen Permutationen müßten überprüfen: typeof(Validates<string>),typeof(Validates<SomeCustomType>) usw ...

Wenn meiner Meinung nach je nach Typ eine benutzerdefinierte Validierung erforderlich ist, ist ein Attribut möglicherweise nicht der beste Ansatz.

Vielleicht wäre eine Validierungsklasse, die einen SomeCustomValidationDelegateoder einen ISomeCustomValidatorals Parameter verwendet, ein besserer Ansatz.

Dies ist derzeit keine C # -Sprachenfunktion, es gibt jedoch viele Diskussionen über das offizielle C # -Sprach-Repo .

Aus einigen Besprechungsnotizen :

Obwohl dies im Prinzip funktionieren würde, gibt es in den meisten Versionen der Laufzeit Fehler, so dass es nicht richtig funktioniert (es wurde nie ausgeführt).

Wir brauchen einen Mechanismus, um zu verstehen, auf welcher Ziellaufzeit es funktioniert. Wir brauchen das für viele Dinge und schauen uns das derzeit an. Bis dahin können wir es nicht ertragen.

Kandidat für eine wichtige C # -Version, wenn wir eine ausreichende Anzahl von Laufzeitversionen dafür bereitstellen können.

Meine Problemumgehung ist ungefähr so:

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