Was sind Attribute in .NET?

StackOverflow https://stackoverflow.com/questions/20346

Frage

Was sind Attribute in .NET, wofür sind sie gut und wie erstelle ich meine eigenen Attribute?

War es hilfreich?

Lösung

Metadaten.Daten zu Ihren Objekten/Methoden/Eigenschaften.

Ich könnte zum Beispiel ein Attribut mit dem Namen deklarieren:DisplayOrder, damit ich einfach steuern kann, in welcher Reihenfolge Eigenschaften in der Benutzeroberfläche angezeigt werden sollen.Ich könnte es dann an eine Klasse anhängen und einige GUI-Komponenten schreiben, die die Attribute extrahieren und die UI-Elemente entsprechend anordnen.

public class DisplayWrapper
{
    private UnderlyingClass underlyingObject;

    public DisplayWrapper(UnderlyingClass u)
    {
        underlyingObject = u;
    }

    [DisplayOrder(1)]
    public int SomeInt
    {
        get
        {
            return underlyingObject .SomeInt;
        }
    }

    [DisplayOrder(2)]
    public DateTime SomeDate
    {
        get
        {
            return underlyingObject .SomeDate;
        }
    }
}

Dadurch wird sichergestellt, dass SomeInt immer vor SomeDate angezeigt wird, wenn ich mit meinen benutzerdefinierten GUI-Komponenten arbeite.

Sie werden jedoch feststellen, dass sie am häufigsten außerhalb der direkten Codierungsumgebung verwendet werden.Der Windows-Designer verwendet sie beispielsweise ausgiebig, sodass er weiß, wie er mit benutzerdefinierten Objekten umgeht.Verwenden Sie das BrowsableAttribute wie folgt:

[Browsable(false)]
public SomeCustomType DontShowThisInTheDesigner
{
    get{/*do something*/}
}

Weist den Designer an, dies beispielsweise zur Entwurfszeit nicht in den verfügbaren Eigenschaften im Eigenschaftenfenster aufzulisten.

Du könnte Verwenden Sie sie auch für Codegenerierung, Vorkompilierungsvorgänge (z. B. Post-Sharp) oder Laufzeitvorgänge wie Reflection.Emit.Sie könnten beispielsweise einen Code für die Profilerstellung schreiben, der jeden einzelnen Aufruf Ihres Codes transparent verpackt und zeitlich begrenzt.Sie können das Timing über ein Attribut deaktivieren, das Sie bestimmten Methoden zuweisen.

public void SomeProfilingMethod(MethodInfo targetMethod, object target, params object[] args)
{
    bool time = true;
    foreach (Attribute a in target.GetCustomAttributes())
    {
        if (a.GetType() is NoTimingAttribute)
        {
            time = false;
            break;
        }
    }
    if (time)
    {
        StopWatch stopWatch = new StopWatch();
        stopWatch.Start();
        targetMethod.Invoke(target, args);
        stopWatch.Stop();
        HandleTimingOutput(targetMethod, stopWatch.Duration);
    }
    else
    {
        targetMethod.Invoke(target, args);
    }
}

Sie zu deklarieren ist einfach, erstellen Sie einfach eine Klasse, die von Attribute erbt. 

public class DisplayOrderAttribute : Attribute
{
    private int order;

    public DisplayOrderAttribute(int order)
    {
        this.order = order;
    }

    public int Order
    {
        get { return order; }
    }
}

Und denken Sie daran, dass Sie bei Verwendung des Attributs das Suffix „attribute“ weglassen können, der Compiler fügt es für Sie hinzu.

NOTIZ: Attribute allein bewirken nichts – es muss ein anderer Code vorhanden sein, der sie verwendet.Manchmal wurde dieser Code für Sie geschrieben, aber manchmal müssen Sie ihn selbst schreiben.Beispielsweise kümmert sich der C#-Compiler um einige Frameworks, und bestimmte Frameworks verwenden einige (z. B.NUnit sucht beim Laden einer Assembly nach [TestFixture] für eine Klasse und [Test] für eine Testmethode.
Beachten Sie also beim Erstellen Ihres eigenen benutzerdefinierten Attributs, dass es keinerlei Auswirkungen auf das Verhalten Ihres Codes hat.Sie müssen den anderen Teil schreiben, der Attribute überprüft (durch Reflexion) und darauf reagiert.

Andere Tipps

Viele Leute haben geantwortet, aber niemand hat dies bisher erwähnt ...

Attribute werden häufig bei der Reflexion verwendet.Die Reflexion ist schon ziemlich langsam.

Es ist sehr lohnenswert Markieren Sie Ihre benutzerdefinierten Attribute als vorhanden sealed Klassen, um ihre Laufzeitleistung zu verbessern.

Es ist auch eine gute Idee, zu überlegen, wo es angebracht wäre, ein solches Attribut zu platzieren, und Ihr Attribut (!) zuzuordnen, um dies anzuzeigen AttributeUsage.Die Liste der verfügbaren Attributverwendungen könnte Sie überraschen:

  • Montage
  • Modul
  • Klasse
  • Struktur
  • Aufzählung
  • Konstrukteur
  • Methode
  • Eigentum
  • Feld
  • Ereignis
  • Schnittstelle
  • Parameter
  • Delegieren
  • Rückgabewert
  • GenericParameter
  • Alle

Cool ist auch, dass das AttributeUsage-Attribut Teil der Signatur des AttributeUsage-Attributs ist.Whoa für zirkuläre Abhängigkeiten!

[AttributeUsageAttribute(AttributeTargets.Class, Inherited = true)]
public sealed class AttributeUsageAttribute : Attribute

Attribute sind eine Art Metadaten zum Markieren von Klassen.Dies wird in WinForms häufig verwendet, um beispielsweise Steuerelemente aus der Symbolleiste auszublenden, kann aber auch in Ihrer eigenen Anwendung implementiert werden, um Instanzen verschiedener Klassen ein bestimmtes Verhalten zu ermöglichen.

Beginnen Sie mit der Erstellung eines Attributs:

[AttributeUsage(AttributeTargets.Class, AllowMultiple=false, Inherited=true)]
public class SortOrderAttribute : Attribute
{
    public int SortOrder { get; set; }

    public SortOrderAttribute(int sortOrder)
    {
        this.SortOrder = sortOrder;
    }
}

Alle Attributklassen müssen das Suffix „Attribute“ haben, um gültig zu sein.
Erstellen Sie anschließend eine Klasse, die das Attribut verwendet.

[SortOrder(23)]
public class MyClass
{
    public MyClass()
    {
    }
}

Jetzt können Sie eine bestimmte Klasse überprüfen. SortOrderAttribute (falls vorhanden), indem Sie Folgendes tun:

public class MyInvestigatorClass
{
    public void InvestigateTheAttribute()
    {
        // Get the type object for the class that is using
        // the attribute.
        Type type = typeof(MyClass);

        // Get all custom attributes for the type.
        object[] attributes = type.GetCustomAttributes(
            typeof(SortOrderAttribute), true);

        // Now let's make sure that we got at least one attribute.
        if (attributes != null && attributes.Length > 0)
        {
            // Get the first attribute in the list of custom attributes
            // that is of the type "SortOrderAttribute". This should only
            // be one since we said "AllowMultiple=false".
            SortOrderAttribute attribute = 
                attributes[0] as SortOrderAttribute;

            // Now we can get the sort order for the class "MyClass".
            int sortOrder = attribute.SortOrder;
        }
    }
}

Wenn Sie mehr darüber lesen möchten, können Sie jederzeit einen Blick darauf werfen MSDN Das hat eine ziemlich gute Beschreibung.
Ich hoffe, das hat dir weitergeholfen!

Ein Attribut ist eine Klasse, die einige Funktionen enthält, die Sie auf Objekte in Ihrem Code anwenden können.Um eine zu erstellen, erstellen Sie eine Klasse, die von System.Attribute erbt.

Wozu sie gut sind...Es gibt nahezu unbegrenzte Einsatzmöglichkeiten für sie.

http://www.codeproject.com/KB/cs/dotnetattributes.aspx

Attribute sind wie Metadaten, die auf Klassen, Methoden oder Assemblys angewendet werden.

Sie eignen sich für viele Dinge (Debugger-Visualisierung, Markieren von Dingen als veraltet, Markieren von Dingen als serialisierbar, die Liste ist endlos).

Das Erstellen eigener benutzerdefinierter Designs ist kinderleicht.Fang hier an:

http://msdn.microsoft.com/en-us/library/sw480ze8(VS.71).aspx

In dem Projekt, an dem ich gerade arbeite, gibt es eine Reihe von UI-Objekten verschiedener Varianten und einen Editor zum Zusammenstellen dieser Objekte, um Seiten für die Verwendung in der Hauptanwendung zu erstellen, ähnlich wie der Formulardesigner in DevStudio.Diese Objekte existieren in einer eigenen Assembly und jedes Objekt ist eine von ihm abgeleitete Klasse UserControl und verfügt über ein benutzerdefiniertes Attribut.Dieses Attribut ist wie folgt definiert:

[AttributeUsage (AttributeTargets::Class)]
public ref class ControlDescriptionAttribute : Attribute
{
public:
  ControlDescriptionAttribute (String ^name, String ^description) :
    _name (name),
    _description (description)
  {
  }

  property String ^Name
  {
    String ^get () { return _name; }
  }

  property String ^Description
  {
    String ^get () { return _description; }
  }

private:
  String
    ^ _name,
    ^ _description;
};

und ich wende es auf eine Klasse wie diese an:

[ControlDescription ("Pie Chart", "Displays a pie chart")]
public ref class PieControl sealed : UserControl
{
  // stuff
};

Das ist es, was die vorherigen Poster gesagt haben.

Um das Attribut zu verwenden, verfügt der Editor über eine Generic::List <Type> enthält die Kontrolltypen.Es gibt ein Listenfeld, das der Benutzer per Drag-and-Drop auf die Seite ziehen kann, um eine Instanz des Steuerelements zu erstellen.Um das Listenfeld zu füllen, erhalte ich das ControlDescriptionAttribute für die Steuerung und füllen Sie einen Eintrag in der Liste aus:

// done for each control type
array <Object ^>
  // get all the custom attributes
  ^attributes = controltype->GetCustomAttributes (true);

Type
  // this is the one we're interested in
  ^attributetype = ECMMainPageDisplay::ControlDescriptionAttribute::typeid;

// iterate over the custom attributes
for each (Object ^attribute in attributes)
{
  if (attributetype->IsInstanceOfType (attribute))
  {
    ECMMainPageDisplay::ControlDescriptionAttribute
      ^description = safe_cast <ECMMainPageDisplay::ControlDescriptionAttribute ^> (attribute);

    // get the name and description and create an entry in the list
    ListViewItem
      ^item = gcnew ListViewItem (description->Name);

    item->Tag = controltype->Name;
    item->SubItems->Add (description->Description);

    mcontrols->Items->Add (item);
    break;
  }
}

Notiz:Das obige ist C ++/CLI, aber es ist nicht schwierig, in C# zu konvertieren (ja, ich weiß, C ++/CLI ist ein Greuel, aber es ist das, womit ich arbeiten muss :-()

Sie können den meisten Dingen Attribute hinzufügen und es gibt eine ganze Reihe vordefinierter Attribute.Der oben erwähnte Editor sucht auch nach benutzerdefinierten Attributen für Eigenschaften, die die Eigenschaft beschreiben und wie sie bearbeitet werden kann.

Sobald Sie die Gesamtidee verstanden haben, werden Sie sich fragen, wie Sie jemals ohne sie gelebt haben.

Wie gesagt, Attribute sind relativ einfach zu erstellen.Der andere Teil der Arbeit besteht darin, Code zu erstellen, der ihn verwendet.In den meisten Fällen verwenden Sie Reflektion zur Laufzeit, um das Verhalten basierend auf dem Vorhandensein eines Attributs oder seiner Eigenschaften zu ändern.Es gibt auch Szenarien, in denen Sie Attribute im kompilierten Code untersuchen, um eine Art statische Analyse durchzuführen.Beispielsweise können Parameter als ungleich Null markiert werden und das Analysetool kann dies als Hinweis verwenden.

Der Großteil der Arbeit besteht darin, die Attribute zu verwenden und die geeigneten Szenarien für ihre Verwendung zu kennen.

Attribute sind im Wesentlichen Datenbits, die Sie Ihrem Gerät hinzufügen möchten Typen (Klassen, Methoden, Ereignisse, Aufzählungen usw.)

Die Idee ist, dass zur Laufzeit ein anderer Typ/Framework/Tool eine Abfrage durchführt dein Geben Sie die Informationen im Attribut ein und handeln Sie danach.

So kann Visual Studio beispielsweise die Attribute eines Drittanbieter-Steuerelements abfragen, um herauszufinden, welche Eigenschaften des Steuerelements zur Entwurfszeit im Eigenschaftenbereich angezeigt werden sollen.

Attribute können auch in der aspektorientierten Programmierung verwendet werden, um Objekte zur Laufzeit basierend auf den Attributen, die sie schmücken, einzufügen/zu manipulieren und Validierung, Protokollierung usw. hinzuzufügen.zu den Objekten, ohne die Geschäftslogik des Objekts zu beeinträchtigen.

Sie können benutzerdefinierte Attribute als einfache Möglichkeit verwenden, Tag-Werte in Unterklassen zu definieren, ohne für jede Unterklasse immer wieder denselben Code schreiben zu müssen.Ich bin auf ein schönes gestoßen prägnantes Beispiel von John Waters wie Sie benutzerdefinierte Attribute in Ihrem eigenen Code definieren und verwenden.

Ein Tutorial gibt es unter http://msdn.microsoft.com/en-us/library/aa288454(VS.71).aspx

Um mit der Erstellung eines Attributs zu beginnen, öffnen Sie eine C#-Quelldatei und geben Sie Folgendes ein attribute und drücken Sie [TAB].Es wird zu einer Vorlage für ein neues Attribut erweitert.

Attribute werden auch häufig für die aspektorientierte Programmierung verwendet.Ein Beispiel hierfür finden Sie im PostSharp Projekt.

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top