Können Attribute in C # dynamisch hinzugefügt werden?

Ist es möglich, zur Laufzeit Attribute hinzuzufügen oder den Wert eines Attributs zur Laufzeit zu ändern?

Attribute sind statische Metadaten. Baugruppen, Module, Typen, Elemente, Parameter und Rückgabewerte sind in C # keine erstklassigen Objekte (z. B. ist die System.TypeKlasse lediglich eine reflektierte Darstellung eines Typs). Sie können eine Instanz eines Attributs für einen Typ abrufen und die Eigenschaften ändern, wenn sie beschreibbar sind. Dies wirkt sich jedoch nicht auf das Attribut aus, wenn es auf den Typ angewendet wird.

Dies hängt wirklich davon ab, was genau Sie erreichen möchten.

Mit dem System.ComponentModel.TypeDescriptor- Material können Typen, Eigenschaften und Objektinstanzen Attribute hinzugefügt werden, und es besteht die Einschränkung, dass Sie es auch zum Abrufen dieser Eigenschaften verwenden müssen. Wenn Sie den Code schreiben, der diese Attribute verwendet, und Sie innerhalb dieser Einschränkungen leben können, würde ich es definitiv vorschlagen.

Soweit ich weiß, sind das PropertyGrid-Steuerelement und die Oberfläche des Visual Studio-Designs die einzigen Dinge in der BCL, die das TypeDescriptor-Material verbrauchen. Auf diese Weise tun sie ungefähr die Hälfte der Dinge, die sie wirklich tun müssen.

Das kannst du nicht. Eine Problemumgehung könnte darin bestehen, zur Laufzeit eine abgeleitete Klasse zu generieren und das Attribut hinzuzufügen, obwohl dies wahrscheinlich ein wenig übertrieben ist.

Um anders zu sein, habe ich einen Artikel gefunden, der auf Reflection verweist.

Hier ist der Link: http://www.codeproject.com/KB/cs/dotnetattributes.aspx . Sie sollten auch einige der Kommentare am Ende des Artikels lesen, da mögliche Ansätze diskutiert werden.

Nein, ist es nicht.

Attribute sind Metadaten und werden in binärer Form in der kompilierten Assembly gespeichert (deshalb können Sie auch nur einfache Typen in ihnen verwenden).

Ich glaube nicht. Selbst wenn ich falsch liege, können Sie nur hoffen, sie einem ganzen Typ hinzuzufügen, niemals einer Instanz eines Typs.

Wenn Sie etwas benötigen, um dynamisch hinzugefügt werden zu können, sind c # -Attribute nicht der richtige Weg. Sehen Sie sich an, wie Sie die Daten in XML speichern. Ich habe kürzlich ein Projekt durchgeführt, das ich mit Attributen gestartet habe, aber schließlich zur Serialisierung mit XML übergegangen bin.

Warum musst du? Attribute geben zusätzliche Informationen zur Reflexion, aber wenn Sie extern wissen, welche Eigenschaften Sie möchten, benötigen Sie sie nicht.

Sie können Metadaten relativ einfach extern in einer Datenbank oder einer Ressourcendatei speichern.

Ich habe mich mit System.ComponentModel.TypeDescriptor sehr bemüht, ohne Erfolg. Das bedeutet nicht, dass es nicht funktionieren kann, aber ich würde gerne Code dafür sehen.

Im Gegenzug wollte ich einige Attributwerte ändern. Ich habe 2 Funktionen ausgeführt, die für diesen Zweck gut funktionieren.

        // ************************************************************************
        public static void SetObjectPropertyDescription(this Type typeOfObject, string propertyName,  string description)
        {
            PropertyDescriptor pd = TypeDescriptor.GetProperties(typeOfObject)[propertyName];
            var att = pd.Attributes[typeof(DescriptionAttribute)] as DescriptionAttribute;
            if (att != null)
            {
                var fieldDescription = att.GetType().GetField("description", BindingFlags.NonPublic | BindingFlags.Instance);
                if (fieldDescription != null)
                {
                    fieldDescription.SetValue(att, description);
                }
            }
        }

        // ************************************************************************
        public static void SetPropertyAttributReadOnly(this Type typeOfObject, string propertyName, bool isReadOnly)
        {
            PropertyDescriptor pd = TypeDescriptor.GetProperties(typeOfObject)[propertyName];
            var att = pd.Attributes[typeof(ReadOnlyAttribute)] as ReadOnlyAttribute;
            if (att != null)
            {
                var fieldDescription = att.GetType().GetField("isReadOnly", BindingFlags.NonPublic | BindingFlags.Instance);
                if (fieldDescription != null)
                {
                    fieldDescription.SetValue(att, isReadOnly);
                }
            }
        }

In Java habe ich dies umgangen, indem ich eine Karte verwendet und meine eigene Version der Schlüsselwertcodierung implementiert habe.

http://developer.apple.com/documentation/Cocoa/Conceptual/KeyValueCoding/KeyValueCoding.html