Freigeben über

Anleitung zur XAML-Syntax

  • Artikel

Wir erläutern XAML-Syntaxregeln und die Terminologie, die die für die XAML-Syntax verfügbaren Einschränkungen oder Auswahlmöglichkeiten beschreibt. Sie finden dieses Thema hilfreich, wenn Sie noch nicht mit der XAML-Sprache arbeiten, eine Aktualisierung der Terminologie oder Teile der Syntax wünschen, oder Sie sind neugierig, wie die XAML-Sprache funktioniert und mehr Hintergrund und Kontext wünschen.

XAML ist XML

Extensible Application Markup Language (XAML) verfügt über eine grundlegende Syntax, die auf XML basiert, und gültiges XAML muss standardmäßig gültiges XML sein. XAML verfügt jedoch auch über eigene Syntaxkonzepte, die XML erweitern. Eine bestimmte XML-Entität kann in nur XML gültig sein, aber diese Syntax hat möglicherweise eine andere und umfassendere Bedeutung als XAML. In diesem Thema werden diese XAML-Syntaxkonzepte erläutert.

XAML-Vokabular

Ein Bereich, in dem XAML sich von den meisten XML-Verwendungen unterscheidet, besteht darin, dass XAML in der Regel nicht mit einem Schema erzwungen wird, z. B. einer XSD-Datei. Der Grund dafür ist, dass XAML erweiterbar sein soll, was das "X" im Akronym-XAML bedeutet. Nachdem XAML analysiert wurde, werden die Elemente und Attribute, auf die Sie in XAML verweisen, in einer sicherungsbasierten Codedarstellung, entweder in den Kerntypen, die durch die Windows-Runtime definiert werden, oder in Typen vorhanden sein, die den Windows-Runtime erweitern oder basieren. Die SDK-Dokumentation bezieht sich manchmal auf die Typen, die bereits in das Windows-Runtime integriert sind und in XAML als XAML-Vokabular für die Windows-Runtime verwendet werden können. Microsoft Visual Studio hilft Ihnen, Markup zu erstellen, das in diesem XAML-Vokabular gültig ist. Visual Studio kann auch Ihre benutzerdefinierten Typen für die XAML-Verwendung enthalten, solange die Quelle dieser Typen im Projekt korrekt referenziert wird. Weitere Informationen zu XAML und benutzerdefinierten Typen finden Sie unter XAML-Namespaces und Namespacezuordnung.

Deklarieren von Objekten

Programmierer denken häufig an Objekte und Member, während eine Markupsprache als Elemente und Attribute konzipiert ist. Im einfachsten Sinne wird ein Element, das Sie im XAML-Markup deklarieren, zu einem Objekt in einer zugrunde stehenden Laufzeitobjektdarstellung. Um ein Laufzeitobjekt für Ihre App zu erstellen, deklarieren Sie ein XAML-Element im XAML-Markup. Das Objekt wird erstellt, wenn die Windows-Runtime den XAML-Code lädt.

Eine XAML-Datei verfügt immer über genau ein Element, das als Stamm dient, wodurch ein Objekt deklariert wird, das der konzeptionelle Stamm einer Programmierstruktur wie einer Seite oder das Objektdiagramm der gesamten Laufzeitdefinition einer Anwendung sein wird.

Im Hinblick auf die XAML-Syntax gibt es drei Möglichkeiten, Objekte in XAML zu deklarieren:

  • Direkt mithilfe der Objektelementsyntax: Dadurch werden öffnende und schließende Tags verwendet, um ein Objekt als XML-Formularelement zu instanziieren. Mit dieser Syntax können Sie Stammobjekte deklarieren oder geschachtelte Objekte erstellen, die Eigenschaftswerte festlegen.
  • Indirekt verwendet die Attributsyntax: Hierbei wird ein Inlinezeichenfolgenwert verwendet, der Anweisungen zum Erstellen eines Objekts enthält. Der XAML-Parser verwendet diese Zeichenfolge, um den Wert einer Eigenschaft auf einen neu erstellten Verweiswert festzulegen. Die Unterstützung ist auf bestimmte allgemeine Objekte und Eigenschaften beschränkt.
  • Verwenden einer Markuperweiterung.

Dies bedeutet nicht, dass Sie immer die Wahl einer Syntax für die Objekterstellung in einem XAML-Vokabular haben. Einige Objekte können nur mithilfe der Objektelementsyntax erstellt werden. Einige Objekte können nur erstellt werden, indem sie zunächst in einem Attribut festgelegt werden. Tatsächlich sind Objekte, die mit Objektelement oder Attributsyntax erstellt werden können, in XAML-Vokabularen vergleichsweise selten. Auch wenn beide Syntaxformen möglich sind, wird eine der Syntaxen häufiger als Formatvorlage verwendet. Es gibt auch Techniken, die Sie in XAML verwenden können, um auf vorhandene Objekte zu verweisen, anstatt neue Werte zu erstellen. Die vorhandenen Objekte können entweder in anderen Bereichen von XAML definiert werden oder implizit durch ein Verhalten der Plattform und der zugehörigen Anwendungs- oder Programmiermodelle vorhanden sein.

Deklarieren eines Objekts mithilfe der Objektelementsyntax

Um ein Objekt mit objektelementsyntax zu deklarieren, schreiben Sie Tags wie folgt: <objectName> </objectName>, wobei objectName der Typname für das Objekt ist, das Sie instanziieren möchten. Hier sehen Sie die Objektelementverwendung zum Deklarieren eines Canvas-Objekts:

<Canvas>
</Canvas>

Wenn das Objekt keine anderen Objekte enthält, können Sie das Objektelement deklarieren, indem Sie ein selbstschließendes Tag anstelle eines öffnenden/schließenden Paares verwenden: <Canvas />

Container

Viele Objekte, die als UI-Elemente verwendet werden, z . B. Canvas, können andere Objekte enthalten. Diese werden manchmal als Container bezeichnet. Das folgende Beispiel zeigt einen Canvas-Container mit einem Element, einem Rechteck.

<Canvas>
  <Rectangle />
</Canvas>

Deklarieren eines Objekts mithilfe der Attributsyntax

Da dieses Verhalten an die Einstellung von Eigenschaften gebunden ist, werden wir in den kommenden Abschnitten mehr darüber sprechen.

Initialisierungstext

Bei einigen Objekten können Sie neue Werte mit innerem Text deklarieren, der als Initialisierungswerte für die Konstruktion verwendet wird. In XAML wird diese Technik und Syntax als Initialisierungstext bezeichnet. Der Initialisierungstext ähnelt dem Aufrufen eines Konstruktors mit Parametern. Initialisierungstext eignet sich zum Festlegen von Anfangswerten bestimmter Strukturen.

Häufig verwenden Sie eine Objektelementsyntax mit Initialisierungstext, wenn Sie einen Strukturwert mit einem x:Key verwenden möchten, damit er in einem ResourceDictionary vorhanden sein kann. Dies ist möglicherweise der Fall, wenn Sie diesen Strukturwert für mehrere Zieleigenschaften freigeben. Bei einigen Strukturen können Sie die Attributsyntax nicht verwenden, um die Werte der Struktur festzulegen: Initialisierungstext ist die einzige Möglichkeit, eine nützliche und gemeinsam nutzbare CornerRadius-, Thickness-, GridLength- oder Color-Ressource zu erzeugen.

In diesem abgekürzten Beispiel wird Initialisierungstext verwendet, um Werte für eine Stärke anzugeben. In diesem Fall geben Sie Werte an, die sowohl "Links" als auch "Rechts" auf "20" und "Oben" und "Unten" auf 10 festlegen. In diesem Beispiel wird die Als Schlüsselressource erstellte Stärke und dann der Verweis auf diese Ressource dargestellt. Weitere Informationen zum Text für die Stärkeinitialisierung finden Sie unter "Thickness".

<UserControl ...>
  <UserControl.Resources>
    <Thickness x:Key="TwentyTenThickness">20,10</Thickness>
    ....
  </UserControl.Resources>
  ...
  <Grid Margin="{StaticResource TwentyTenThickness}">
  ...
  </Grid>
</UserControl ...>

Beachten Sie, dass einige Strukturen nicht als Objektelemente deklariert werden können. Initialisierungstext wird nicht unterstützt und kann nicht als Ressourcen verwendet werden. Sie müssen eine Attributsyntax verwenden, um Eigenschaften auf diese Werte in XAML festzulegen. Diese Typen sind: Duration, RepeatBehavior, Point, Rect und Size.

Festlegen von Eigenschaften

Sie können Eigenschaften für Objekte festlegen, die Sie mithilfe der Objektelementsyntax deklariert haben. Es gibt mehrere Möglichkeiten zum Festlegen von Eigenschaften in XAML:

  • Mithilfe der Attributsyntax.
  • Mithilfe der Eigenschaftselementsyntax.
  • Mithilfe der Elementsyntax, bei der der Inhalt (innerer Text oder untergeordnete Elemente) die XAML-Inhaltseigenschaft eines Objekts festlegt.
  • Mithilfe einer Sammlungssyntax (dies ist in der Regel die implizite Sammlungssyntax).

Wie bei der Objektdeklaration bedeutet diese Liste nicht, dass jede Eigenschaft mit jedem der Techniken festgelegt werden kann. Einige Eigenschaften unterstützen nur eine der Techniken. Einige Eigenschaften unterstützen mehr als ein Formular; Beispielsweise gibt es Eigenschaften, die Eigenschaftselementsyntax oder Attributsyntax verwenden können. Was möglich ist, hängt sowohl von der Eigenschaft als auch vom Objekttyp ab, den die Eigenschaft verwendet. In der Windows-Runtime-API-Referenz sehen Sie die XAML-Verwendungen, die Sie im Abschnitt "Syntax" verwenden können. Manchmal gibt es eine alternative Verwendung, die funktioniert, aber ausführlicher wäre. Diese ausführlichen Verwendungen werden nicht immer angezeigt, da wir versuchen, Ihnen die bewährten Methoden oder die realen Szenarien für die Verwendung dieser Eigenschaft in XAML zu zeigen. Anleitungen für die XAML-Syntax finden Sie in den XAML-Verwendungsabschnitten von Referenzseiten für Eigenschaften, die in XAML festgelegt werden können.

Einige Eigenschaften für Objekte können in XAML nicht auf irgendeine Weise festgelegt werden und können nur mithilfe von Code festgelegt werden. In der Regel sind dies Eigenschaften, die besser geeignet sind, um im CodeBehind zu arbeiten, nicht in XAML.

Eine schreibgeschützte Eigenschaft kann nicht in XAML festgelegt werden. Selbst im Code müsste der besitzereigene Typ eine andere Möglichkeit zum Festlegen unterstützen, z. B. eine Konstruktorüberladung, Hilfsmethode oder berechnete Eigenschaftsunterstützung. Eine berechnete Eigenschaft basiert auf den Werten anderer festgelegter Eigenschaften sowie manchmal einem Ereignis mit integrierter Behandlung; Diese Features sind im Abhängigkeitseigenschaftensystem verfügbar. Weitere Informationen dazu, wie Abhängigkeitseigenschaften für die Unterstützung berechneter Eigenschaften nützlich sind, finden Sie in der Übersicht über Abhängigkeitseigenschaften.

Die Sammlungssyntax in XAML gibt eine Darstellung, dass Sie eine schreibgeschützte Eigenschaft festlegen, aber tatsächlich sind Sie nicht. Weitere Informationen finden Sie weiter unten in diesem Thema unter "Sammlungssyntax".

Festlegen einer Eigenschaft mithilfe der Attributsyntax

Das Festlegen eines Attributwerts ist die typische Methode, mit der Sie einen Eigenschaftswert in einer Markupsprache festlegen, z. B. in XML oder HTML. Das Festlegen von XAML-Attributen ähnelt dem Festlegen von Attributwerten in XML. Der Attributname wird an jedem Punkt innerhalb der Tags nach dem Elementnamen angegeben, getrennt vom Elementnamen durch mindestens ein Leerzeichen. Auf den Attributnamen folgt ein Gleichheitszeichen. Der Attributwert ist innerhalb eines Anführungszeichenpaars enthalten. Die Anführungszeichen können entweder doppelte Anführungszeichen oder einfache Anführungszeichen sein, solange sie übereinstimmen und den Wert einschließen. Der Attributwert selbst muss als Zeichenfolge ausgedrückt werden. Die Zeichenfolge enthält häufig Ziffern, aber für XAML sind alle Attributwerte Zeichenfolgenwerte, bis der XAML-Parser beteiligt wird und eine grundlegende Wertkonvertierung durchführt.

In diesem Beispiel wird die Attributsyntax für vier Attribute verwendet, um die Eigenschaften Name, Width, Height und Fill eines Rectangle-Objekts festzulegen.

<Rectangle Name="rectangle1" Width="100" Height="100" Fill="Blue" />

Festlegen einer Eigenschaft mithilfe der Eigenschaftselementsyntax

Viele Eigenschaften eines Objekts können mithilfe der Eigenschaftselementsyntax festgelegt werden. Ein Eigenschaftselement sieht wie folgt aus: <Objekteigenschaft.>.

Um die Eigenschaftselementsyntax zu verwenden, erstellen Sie XAML-Eigenschaftselemente für die Eigenschaft, die Sie festlegen möchten. In Standard-XML würde dieses Element nur als Element mit einem Punkt im Namen betrachtet. In XAML identifiziert der Punkt im Elementnamen das Element jedoch als Eigenschaftselement, wobei die Eigenschaft in einer zugrunde stehenden Objektmodellimplementierung als Objektelement erwartet wird. Um die Eigenschaftselementsyntax zu verwenden, muss es möglich sein, ein Objektelement anzugeben, um die Eigenschaftselementtags zu "füllen". Ein Eigenschaftselement verfügt immer über inhalte (einzelnes Element, mehrere Elemente oder inneren Text); Es gibt keinen Sinn, ein selbstschließendes Eigenschaftselement zu haben.

In der folgenden Grammatik ist die Eigenschaft der Name der Eigenschaft, die Sie festlegen möchten, und propertyValueAsObjectElement ist ein einzelnes Objektelement, das die Werttypanforderungen der Eigenschaft erfüllen soll.

<object>

<object-Eigenschaft.>

propertyValueAsObjectElement

</object-Eigenschaft.>

</object>

Im folgenden Beispiel wird die Eigenschaftselementsyntax verwendet, um die Füllung eines Rechtecks mit einem SolidColorBrush-Objektelement festzulegen. (Innerhalb der SolidColorBrush, Color wird als Attribut festgelegt.) Das analysierte Ergebnis dieses XAML-Codes ist identisch mit dem vorherigen XAML-Beispiel, das Fill mithilfe der Attributsyntax festgelegt hat.

<Rectangle
  Name="rectangle1"
  Width="100" 
  Height="100"
> 
  <Rectangle.Fill> 
    <SolidColorBrush Color="Blue"/> 
  </Rectangle.Fill>
</Rectangle>

XAML-Vokabular und objektorientierte Programmierung

Eigenschaften und Ereignisse, die als XAML-Member eines Windows-Runtime XAML-Typs angezeigt werden, werden häufig von Basistypen geerbt. Betrachten Sie dieses Beispiel: <Button Background="Blue" .../>. Die Background-Eigenschaft ist keine sofort deklarierte Eigenschaft für die Button-Klasse. Stattdessen wird der Hintergrund von der Basis-Control-Klasse geerbt. Wenn Sie sich das Referenzthema für Schaltfläche ansehen, sehen Sie, dass die Mitgliederlisten mindestens ein geerbtes Element aus jeder Kette aufeinander folgender Basisklassen enthalten: ButtonBase, Control, FrameworkElement, UIElement, DependencyObject. In der Liste "Eigenschaften " werden alle Eigenschaften und Auflistungseigenschaften mit Lese-/Schreibzugriff in XAML-Vokabular geerbt. Auch Ereignisse (wie die verschiedenen UIElement-Ereignisse ) werden geerbt.

Wenn Sie den Windows-Runtime Verweis für XAML-Anleitungen verwenden, wird der Elementname, der in einer Syntax oder sogar im Beispielcode angezeigt wird, manchmal für den Typ verwendet, der die Eigenschaft ursprünglich definiert, da dieses Referenzthema von allen möglichen Typen gemeinsam verwendet wird, die sie von einer Basisklasse erben. Wenn Sie intelliSense für XAML von Visual Studio im XML-Editor verwenden, können IntelliSense und die zugehörigen Dropdowns die Vererbung zusammenführen und eine genaue Liste der Attribute bereitstellen, die für die Einstellung verfügbar sind, sobald Sie mit einem Objektelement für eine Klasseninstanz begonnen haben.

XAML-Inhaltseigenschaften

Einige Typen definieren eine ihrer Eigenschaften, sodass die Eigenschaft eine XAML-Inhaltssyntax ermöglicht. Für die XAML-Inhaltseigenschaft eines Typs können Sie das Eigenschaftselement für diese Eigenschaft weglassen, wenn Sie sie in XAML angeben. Sie können die Eigenschaft auch auf einen inneren Textwert festlegen, indem Sie diesen inneren Text direkt innerhalb der Objektelementtags des eigenen Typs angeben. XAML-Inhaltseigenschaften unterstützen eine einfache Markupsyntax für diese Eigenschaft und machen den XAML-Code besser lesbar, indem die Schachtelung reduziert wird.

Wenn eine XAML-Inhaltssyntax verfügbar ist, wird diese Syntax in den Abschnitten "XAML" der Syntax für diese Eigenschaft in der Windows-Runtime Referenzdokumentation angezeigt. Auf der Seite " Untergeordnete Eigenschaft" für "Rahmen " wird z. B. die XAML-Inhaltssyntax anstelle der Eigenschaftselementsyntax angezeigt, um den Wert "Border.Child " eines Rahmens wie folgt festzulegen:

<Border>
  <Button .../>
</Border>

Wenn die Eigenschaft, die als XAML-Inhaltseigenschaft deklariert ist, der Objekttyp ist oder vom Typ "String" ist, unterstützt die XAML-Inhaltssyntax den im XML-Dokumentmodell im Wesentlichen inneren Text: eine Zeichenfolge zwischen den öffnenden und schließenden Objekttags. Die Text-Eigenschaftenseite für TextBlock zeigt beispielsweise eine XAML-Inhaltssyntax mit einem inneren Textwert zum Festlegen von Text an, die Zeichenfolge "Text" wird jedoch nie im Markup angezeigt. Beispiel zur Verwendung:

<TextBlock>Hello!</TextBlock>

Wenn eine XAML-Inhaltseigenschaft für eine Klasse vorhanden ist, wird dies im Referenzthema für die Klasse im Abschnitt "Attribute" angegeben. Suchen Sie nach dem Wert von ContentPropertyAttribute. Dieses Attribut verwendet ein benanntes Feld "Name". Der Wert von "Name" ist der Name der Eigenschaft dieser Klasse, die die XAML-Inhaltseigenschaft ist. Auf der Seite "Rahmenreferenz " sehen Sie beispielsweise Folgendes: ContentProperty("Name=Child").

Eine wichtige XAML-Syntaxregel, die wir erwähnen sollten, ist, dass Sie die XAML-Inhaltseigenschaft und andere Eigenschaftselemente, die Sie für das Element festgelegt haben, nicht miteinander mischen können. Die XAML-Inhaltseigenschaft muss vollständig vor allen Eigenschaftselementen oder vollständig danach festgelegt werden. Dies ist beispielsweise ungültiger XAML-Code:

<StackPanel>
  <Button>This example</Button>
  <StackPanel.Resources>
    <SolidColorBrush x:Key="BlueBrush" Color="Blue"/>
  </StackPanel.Resources>
  <Button>... is illegal XAML</Button>
</StackPanel>

Sammlungssyntax

Alle bisher gezeigten Syntaxen legen Eigenschaften auf einzelne Objekte fest. Viele Benutzeroberflächenszenarien erfordern jedoch, dass ein bestimmtes übergeordnetes Element mehrere untergeordnete Elemente aufweisen kann. Beispielsweise benötigt eine Benutzeroberfläche für ein Eingabeformular mehrere Textfeldelemente, einige Bezeichnungen und möglicherweise eine Schaltfläche "Absenden". Wenn Sie jedoch ein Programmierobjektmodell verwenden würden, um auf diese mehrere Elemente zuzugreifen, wären sie in der Regel Elemente in einer einzelnen Auflistungseigenschaft, anstatt jedes Element der Wert verschiedener Eigenschaften zu sein. XAML unterstützt mehrere untergeordnete Elemente sowie das Unterstützen eines typischen Sicherungsauflistungsmodells, indem Eigenschaften behandelt werden, die einen Sammlungstyp als implizit verwenden und eine spezielle Behandlung für alle untergeordneten Elemente eines Sammlungstyps ausführen.

Viele Sammlungseigenschaften werden auch als XAML-Inhaltseigenschaft für die Klasse identifiziert. Die Kombination aus impliziter Sammlungsverarbeitung und XAML-Inhaltssyntax wird häufig in Typen gesehen, die für die Steuerelementkompositionen verwendet werden, z. B. Panels, Ansichten oder Elementsteuerelemente. Das folgende Beispiel zeigt beispielsweise den einfachsten XAML-Code zum Kompositieren von zwei Peer-UI-Elementen innerhalb eines StackPanel- Elements.

<StackPanel>
  <TextBlock>Hello</TextBlock>
  <TextBlock>World</TextBlock>
</StackPanel>

Der Mechanismus der XAML-Sammlungssyntax

Es kann zunächst vorkommen, dass XAML einen "Satz" der schreibgeschützten Sammlungseigenschaft aktiviert. Was XAML hier ermöglicht, ist das Hinzufügen von Elementen zu einer vorhandenen Auflistung. Die XAML-Sprache und XAML-Prozessoren, die die XAML-Unterstützung implementieren, basieren auf einer Konvention in Sicherungssammlungstypen, um diese Syntax zu aktivieren. In der Regel gibt es eine Sicherungseigenschaft wie eine Indexer- oder Items-Eigenschaft , die sich auf bestimmte Elemente der Auflistung bezieht. Im Allgemeinen ist diese Eigenschaft in der XAML-Syntax nicht explizit. Bei Auflistungen ist der zugrunde liegende Mechanismus für die XAML-Analyse keine Eigenschaft, sondern eine Methode: insbesondere die Add-Methode in den meisten Fällen. Wenn der XAML-Prozessor auf ein oder mehrere Objektelemente innerhalb einer XAML-Auflistungssyntax stößt, wird jedes solche Objekt zuerst aus einem Element erstellt, und jedes neue Objekt wird der enthaltenden Auflistung hinzugefügt, indem die Add-Methode der Auflistung aufgerufen wird.

Wenn ein XAML-Parser einer Auflistung Elemente hinzufügt, ist es die Logik der Add-Methode , die bestimmt, ob ein bestimmtes XAML-Element ein zulässiges untergeordnetes Element des Auflistungsobjekts ist. Viele Sammlungstypen werden stark von der Sicherungsimplementierung eingegeben, was bedeutet, dass der Eingabeparameter von "Add " erwartet, dass alles, was übergeben wird, ein Typ mit dem Add-Parametertyp übereinstimmen muss.

Achten Sie bei Auflistungseigenschaften darauf, wenn Sie versuchen, die Auflistung explizit als Objektelement anzugeben. Ein XAML-Parser erstellt immer dann ein neues Objekt, wenn es auf ein Objektelement trifft. Wenn die sammlungseigenschaft, die Sie verwenden möchten, schreibgeschützt ist, kann dies eine XAML-Analyseausnahme auslösen. Verwenden Sie einfach die implizite Sammlungssyntax, und diese Ausnahme wird nicht angezeigt.

Wann attribut- oder Eigenschaftselementsyntax verwendet werden soll

Alle Eigenschaften, die das Festlegen in XAML unterstützen, unterstützen die Attribut- oder Eigenschaftselementsyntax für die direkte Werteinstellung, unterstützen aber möglicherweise keine syntax synonym. Einige Eigenschaften unterstützen beide Syntax, und einige Eigenschaften unterstützen zusätzliche Syntaxoptionen wie eine XAML-Inhaltseigenschaft. Der Typ der von einer Eigenschaft unterstützten XAML-Syntax hängt vom Typ des Objekts ab, das von der Eigenschaft als Eigenschaftstyp verwendet wird. Wenn der Eigenschaftstyp ein Grundtyp ist, z. B. ein Double (float oder dezimal), eine ganze Zahl, ein Boolescher Wert oder eine Zeichenfolge, unterstützt die Eigenschaft immer die Attributsyntax.

Sie können auch attributsyntax verwenden, um eine Eigenschaft festzulegen, wenn der Objekttyp, den Sie zum Festlegen dieser Eigenschaft verwenden, durch Verarbeiten einer Zeichenfolge erstellt werden kann. Bei Grundtypen ist dies immer der Fall, die Typkonvertierung ist in den Parser integriert. Bestimmte andere Objekttypen können jedoch auch mithilfe einer als Attributwert angegebenen Zeichenfolge und nicht mithilfe eines Objektelements innerhalb eines Eigenschaftselements erstellt werden. Damit dies funktioniert, muss eine zugrunde liegende Typkonvertierung vorhanden sein, die entweder von dieser bestimmten Eigenschaft unterstützt wird oder allgemein für alle Werte unterstützt wird, die diesen Eigenschaftstyp verwenden. Der Zeichenfolgenwert des Attributs wird verwendet, um Eigenschaften festzulegen, die für die Initialisierung des neuen Objektwerts wichtig sind. Möglicherweise kann ein bestimmter Typkonverter auch unterschiedliche Unterklassen eines allgemeinen Eigenschaftstyps erstellen, je nachdem, wie er Informationen in der Zeichenfolge eindeutig verarbeitet. Objekttypen, die dieses Verhalten unterstützen, weisen eine spezielle Grammatik auf, die im Syntaxabschnitt der Referenzdokumentation aufgeführt ist. Die XAML-Syntax für Brush zeigt beispielsweise, wie eine Attributsyntax verwendet werden kann, um einen neuen SolidColorBrush-Wert für jede Eigenschaft vom Typ Brush zu erstellen (und es gibt viele Pinseleigenschaften in Windows-Runtime XAML).

XAML-Analyselogik und -Regeln

Irgendwann ist es informativ, den XAML-Code auf ähnliche Weise zu lesen, wie ein XAML-Parser es lesen muss: als eine Reihe von Zeichenfolgentoken, die in einer linearen Reihenfolge aufgetreten sind. Ein XAML-Parser muss diese Token unter einer Reihe von Regeln interpretieren, die Teil der Definition der Funktionsweise von XAML sind.

Das Festlegen eines Attributwerts ist die typische Methode, mit der Sie einen Eigenschaftswert in einer Markupsprache festlegen, z. B. in XML oder HTML. In der folgenden Syntax ist objectName das Objekt, das Sie instanziieren möchten, propertyName ist der Name der Eigenschaft, die Sie für dieses Objekt festlegen möchten, und propertyValue ist der festzulegende Wert.

<objectName propertyName="propertyValue" .../>

-or-

<objectName propertyName="propertyValue">

...<!--element children -->

</objectName>

Mit beiden Syntaxen können Sie ein Objekt deklarieren und eine Eigenschaft für dieses Objekt festlegen. Obwohl das erste Beispiel ein einzelnes Element im Markup ist, gibt es hier tatsächlich diskrete Schritte hinsichtlich der Analyse dieses Markups durch einen XAML-Prozessor.

Zunächst gibt das Vorhandensein des Objektelements an, dass ein neues objectName-Objekt instanziiert werden muss. Erst nachdem eine solche Instanz vorhanden ist, kann der Eigenschaftseigenschaftsname der Instanz darauf festgelegt werden.

Eine weitere XAML-Regel besteht darin, dass Attribute eines Elements in beliebiger Reihenfolge festgelegt werden müssen. Beispielsweise gibt es keinen Unterschied zwischen <Rectangle Height="50" Width="100" /> und <Rectangle Width="100" Height="50" />. Welche Reihenfolge Sie verwenden, ist eine Frage des Stils.

Beachten Sie, dass XAML-Designer häufig Sortierkonventionen fördern, wenn Sie andere Entwurfsoberflächen als den XML-Editor verwenden, aber sie später frei bearbeiten können, um die Attribute neu anzuordnen oder neue einzuführen.

Angefügte Eigenschaften

XAML erweitert XML durch Hinzufügen eines Syntaxelements, das als angefügte Eigenschaft bezeichnet wird. Ähnlich wie bei der Eigenschaftselementsyntax enthält die Syntax der angefügten Eigenschaft einen Punkt, und der Punkt enthält eine besondere Bedeutung für die XAML-Analyse. Insbesondere trennt der Punkt den Anbieter der angefügten Eigenschaft und den Eigenschaftennamen.

In XAML legen Sie angefügte Eigenschaften mithilfe der Syntax AttachedPropertyProvider fest.PropertyName Here is an example of how you can set the attached property Canvas.Left in XAML:

<Canvas>
  <Button Canvas.Left="50">Hello</Button>
</Canvas>

Sie können die angefügte Eigenschaft für Elemente festlegen, die nicht über eine Eigenschaft dieses Namens im Sicherungstyp verfügen, und auf diese Weise wie eine globale Eigenschaft oder ein Attribut, das durch einen anderen XML-Namespace wie das xml:space-Attribut definiert wird, funktionieren.

In Windows-Runtime XAML werden angefügte Eigenschaften angezeigt, die diese Szenarien unterstützen:

Weitere Informationen finden Sie unter Übersicht über angefügte Eigenschaften.

Literale "{"-Werte

Da das öffnende Klammernsymbol { das Öffnen der Markuperweiterungssequenz ist, verwenden Sie eine Escapesequenz, um einen Literalzeichenfolgenwert anzugeben, der mit "{" beginnt. Die Escapesequenz lautet "{}". Wenn Sie beispielsweise einen Zeichenfolgenwert angeben möchten, der eine einzelne öffnende geschweifte Klammer ist, geben Sie den Attributwert als "{}{" an. Sie können auch die alternativen Anführungszeichen (z. B. ein ' innerhalb eines durch "" getrennten Attributwerts) verwenden, um einen "{"-Wert als Zeichenfolge anzugeben.

Hinweis "\}" funktioniert auch, wenn es sich innerhalb eines an zitierten Attributs befindet.  

Enumerationswerte

Viele Eigenschaften in der Windows-Runtime-API verwenden Enumerationen als Werte. Wenn das Element eine Lese-/Schreibeigenschaft ist, können Sie eine solche Eigenschaft festlegen, indem Sie einen Attributwert angeben. Sie bestimmen, welcher Enumerationswert als Wert der Eigenschaft verwendet werden soll, indem Sie den nicht qualifizierten Namen des Konstantennamens verwenden. Hier erfahren Sie, wie Sie "UIElement.Visibility" in XAML festlegen: <Button Visibility="Visible"/>. Hier wird "Visible" als Zeichenfolge direkt einer benannten Konstante der Visibility-Aufzählung Visible zugeordnet.

  • Verwenden Sie kein qualifiziertes Formular, es funktioniert nicht. Dies ist beispielsweise ungültiger XAML-Code: <Button Visibility="Visibility.Visible"/>.
  • Verwenden Sie nicht den Wert der Konstante. Verwenden Sie mit anderen Worten nicht den ganzzahligen Wert der Enumeration, die explizit oder implizit vorhanden ist, je nachdem, wie die Enumeration definiert wurde. Obwohl es möglicherweise funktioniert, ist es in XAML oder im Code eine schlechte Methode, da Sie sich darauf verlassen, was ein vorübergehendes Implementierungsdetail sein könnte. Führen Sie dies z. B. nicht aus: <Button Visibility="1"/>.

Hinweis In Referenzthemen für APIs, die XAML verwenden und Enumerationen verwenden, klicken Sie auf den Link zum Enumerationstyp im Eigenschaftenwertabschnitt der Syntax. Dieser Link verweist auf die Enumerationsseite, auf der Sie die benannten Konstanten für diese Enumeration ermitteln können.

Enumerationen können flagweise sein, d. h., sie werden mit FlagsAttribute attributiert. Wenn Sie eine Kombination von Werten für eine flagwise-Aufzählung als XAML-Attributwert angeben müssen, verwenden Sie den Namen jeder Enumerationskonstante mit einem Komma (,) zwischen jedem Namen und keine dazwischen liegenden Leerzeichen. Flagwise attribute aren't common in the Windows-Runtime XAML vokabular, but ManipulationModes is an example where setting a flagwise enumeration value in XAML is supported.

Schnittstellen in XAML

In seltenen Fällen wird eine XAML-Syntax angezeigt, bei der der Typ einer Eigenschaft eine Schnittstelle ist. Im XAML-Typsystem ist ein Typ, der diese Schnittstelle implementiert, beim Analysieren als Wert akzeptabel. Es muss eine erstellte Instanz eines solchen Typs vorhanden sein, die als Wert dienen kann. Es wird eine Schnittstelle angezeigt, die als Typ in der XAML-Syntax für command- und CommandParameter-Eigenschaften von ButtonBase verwendet wird. Diese Eigenschaften unterstützen Model-View-ViewModel (MVVM)-Entwurfsmuster, bei denen die ICommand-Schnittstelle der Vertrag für die Interaktion der Ansichten und Modelle ist.

XAML-Platzhalterkonventionen in Windows-Runtime Referenz

Wenn Sie einen der Syntaxabschnitt der Referenzthemen für Windows-Runtime-APIs untersucht haben, die XAML verwenden können, haben Sie wahrscheinlich gesehen, dass die Syntax einige Platzhalter enthält. Die XAML-Syntax unterscheidet sich von der Syntax der C#-, Microsoft Visual Basic- oder Visual C++-Komponentenerweiterungen (C++/CX), da die XAML-Syntax eine Verwendungssyntax ist. Es wird auf Ihre letztendliche Verwendung in Ihren eigenen XAML-Dateien hinweist, aber ohne überschreibend zu den Werten zu sein, die Sie verwenden können. In der Regel beschreibt die Verwendung einen Grammatiktyp, der Literale und Platzhalter kombiniert und einige der Platzhalter im XAML-Werteabschnitt definiert.

Wenn Typnamen/Elementnamen in einer XAML-Syntax für eine Eigenschaft angezeigt werden, gilt der angezeigte Name für den Typ, der die Eigenschaft ursprünglich definiert. Windows-Runtime XAML unterstützt jedoch ein Klassenvererbungsmodell für die DependencyObject-basierten Klassen. Sie können also häufig ein Attribut für eine Klasse verwenden, die nicht buchstäblich die definierende Klasse ist, sondern von einer Klasse abgeleitet wird, die zuerst die Eigenschaft/das Attribut definiert hat. Beispielsweise können Sie Visibility als Attribut für jede von UIElement abgeleitete Klasse mithilfe einer tiefen Vererbung festlegen. Beispiel: <Button Visibility="Visible" /> Nehmen Sie also nicht den Elementnamen, der in einer XAML-Verwendungssyntax angezeigt wird, zu wörtlich; die Syntax kann für Elemente geeignet sein, die diese Klasse darstellen, und auch Elemente, die eine abgeleitete Klasse darstellen. In Fällen, in denen es selten oder unmöglich ist, dass sich der Typ als das definierende Element in einer realen Verwendung befindet, wird dieser Typname absichtlich in der Syntax kleingeschrieben. Die für UIElement.Visibility angezeigte Syntax lautet beispielsweise:

<uiElement Visibility="Visible"/>
-or-
<uiElement Visibility="Collapsed"/>

Viele XAML-Syntaxabschnitte enthalten Platzhalter in der "Usage", die dann in einem XAML-Werteabschnitt definiert werden, der sich direkt unter dem Syntaxabschnitt befindet.

XAML-Verwendungsabschnitte verwenden auch verschiedene generalisierte Platzhalter. Diese Platzhalter werden nicht jedes Mal in XAML-Werten neu definiert, da Sie erraten oder schließlich erfahren, was sie darstellen. Wir denken, dass die meisten Leser sie immer wieder in XAML-Werten sehen würden, sodass wir sie aus den Definitionen herausgelassen haben. Als Referenz finden Sie hier eine Liste einiger dieser Platzhalter und was sie im allgemeinen bedeuten:

  • -Objekt: Theoretisch beliebiger Objektwert, aber oft praktisch auf bestimmte Objekttypen wie eine Zeichenfolgen- oder Objektauswahl beschränkt, und Sie sollten die Hinweise auf der Referenzseite auf weitere Informationen überprüfen.
  • object property: object property in combination is used for cases where the syntax being shown is the syntax for a type that can be used as an attribute value for many properties. Die für Brush gezeigte Xaml-Attributverwendung umfasst beispielsweise: <object property="predefinedColorName"/>
  • ereignishandler: Dies wird als Attributwert für jede XAML-Syntax angezeigt, die für ein Ereignisattribute angezeigt wird. Hier geben Sie den Funktionsnamen für eine Ereignishandlerfunktion an. Diese Funktion muss im CodeBehind für die XAML-Seite definiert werden. Auf Programmierebene muss diese Funktion mit der Stellvertretungssignatur des ereignisses übereinstimmen, das Sie behandeln, oder Ihr App-Code wird nicht kompiliert. Aber das ist wirklich eine Programmierüberlegung, keine XAML-Überlegung, daher versuchen wir nicht, etwas über den Delegattyp in der XAML-Syntax zu hinweisen. Wenn Sie wissen möchten, welche Stellvertretung Sie für ein Ereignis implementieren sollten, befindet sich dies im Abschnitt "Ereignisinformationen " des Referenzthemas für das Ereignis in einer Tabellenzeile mit der Bezeichnung "Delegate".
  • enumMemberName: in Attributsyntax für alle Enumerationen angezeigt. Es gibt einen ähnlichen Platzhalter für Eigenschaften, die einen Enumerationswert verwenden, aber in der Regel wird dem Platzhalter ein Hinweis auf den Namen der Enumeration vorangestellt. Die syntax für "FrameworkElement.FlowDirection" lautet< beispielsweise "frameworkElementFlowDirection="flowDirectionMemberName"/>. Wenn Sie sich auf einer dieser Eigenschaftenverweisseiten befinden, klicken Sie auf den Link zum Enumerationstyp, der im Abschnitt "Eigenschaftswert " neben dem Text "Typ:" angezeigt wird. Für den Attributwert einer Eigenschaft, die diese Enumeration verwendet, können Sie eine beliebige Zeichenfolge verwenden, die in der Memberspalte der Mitgliederliste aufgeführt ist.
  • double, int, string, bool: Dies sind Grundtypen, die der XAML-Sprache bekannt sind. Wenn Sie mit C# oder Visual Basic programmieren, werden diese Typen auf Microsoft .NET-äquivalente Typen wie Double, Int32, String und Boolean projiziert, und Sie können alle Member dieser .NET-Typen verwenden, wenn Sie mit Ihren XAML-definierten Werten in .NET CodeBehind arbeiten. Wenn Sie mit C++/CX programmieren, verwenden Sie die C++-Grundtypen, sie können aber auch die gleichen Typen berücksichtigen, die vom Platform-Namespace definiert sind, z. B. Platform::String. Es gibt manchmal zusätzliche Wertbeschränkungen für bestimmte Eigenschaften. In der Regel werden diese in einem Abschnitt "Eigenschaftswert " oder "Hinweise" und nicht in einem XAML-Abschnitt aufgeführt, da solche Einschränkungen sowohl für Codeverwendungen als auch für XAML-Verwendungen gelten.

Tipps und Tricks, Notizen im Stil

  • Markuperweiterungen werden im Allgemeinen in der Haupt-XAML-Übersicht beschrieben. Die Markuperweiterung, die sich am meisten auf die anleitung in diesem Thema auswirkt, ist jedoch die StaticResource-Markuperweiterung (und verwandte ThemeResource). Die Funktion der StaticResource-Markuperweiterung besteht darin, den XAML-Code in wiederverwendbare Ressourcen zu integrieren, die aus einem XAML-ResourceDictionary stammen. Sie definieren fast immer Steuerelementvorlagen und zugehörige Stile in einem ResourceDictionary. Sie definieren häufig auch die kleineren Teile einer Steuerelementvorlagendefinition oder app-spezifischen Formatvorlage in einem ResourceDictionary, z. B. einen SolidColorBrush für eine Farbe, die Ihre App für verschiedene Teile der Benutzeroberfläche mehrmals verwendet. Wenn Sie eine StaticResource verwenden, können alle Eigenschaften, die andernfalls eine Eigenschaftselementverwendung zum Festlegen erfordern, jetzt in der Attributsyntax festgelegt werden. Die Vorteile der Wiederverwendung von XAML für die Wiederverwendung gehen jedoch über die Vereinfachung der Syntax auf Seitenebene hinaus. Weitere Informationen finden Sie unter ResourceDictionary- und XAML-Ressourcenverweise.
  • Es werden verschiedene Konventionen für die Anwendung von Leerzeichen und Zeilenfeeds in XAML-Beispielen angezeigt. Insbesondere gibt es unterschiedliche Konventionen zum Aufteilen von Objektelementen mit einer Vielzahl unterschiedlicher Attribute. Das ist nur eine Frage des Stils. Der XML-Editor von Visual Studio wendet beim Bearbeiten von XAML einige Standardstilregeln an, aber Sie können diese in den Einstellungen ändern. Es gibt eine kleine Anzahl von Fällen, in denen der Leerraum in einer XAML-Datei als signifikant angesehen wird; weitere Informationen finden Sie unter XAML und Leerzeichen.