Delen via

XAML-syntaxishandleiding

We leggen XAML-syntaxisregels en de terminologie uit die de beperkingen of keuzes beschrijft die beschikbaar zijn voor XAML-syntaxis. U vindt dit onderwerp nuttig als u niet eerder de XAML-taal gebruikt, u een vernieuwer wilt over de terminologie of onderdelen van de syntaxis, of als u wilt weten hoe de XAML-taal werkt en meer achtergrond en context wilt.

XAML is XML

Extensible Application Markup Language (XAML) heeft een basissyntaxis die voortbouwt op XML en per definitie geldige XAML moet geldige XML zijn. Maar XAML heeft ook zijn eigen syntaxisconcepten waarmee XML wordt uitgebreid. Een bepaalde XML-entiteit kan geldig zijn in xml zonder opmaak, maar die syntaxis kan een andere en volledigere betekenis hebben als XAML. In dit onderwerp worden deze XAML-syntaxisconcepten uitgelegd.

XAML-woordenlijsten

Een gebied waar XAML verschilt van het meeste XML-gebruik, is dat XAML doorgaans niet wordt afgedwongen met een schema, zoals een XSD-bestand. Dat komt doordat XAML bedoeld is om uit te breidbaar te zijn, dat is wat de X in het acroniem XAML betekent. Zodra XAML is geparseerd, zijn de elementen en kenmerken waarnaar u in XAML verwijst, naar verwachting aanwezig in een bepaalde weergave van back-upcode, in de kerntypen die zijn gedefinieerd door de Windows Runtime, of in typen die worden uitgebreid of gebaseerd op De Windows Runtime. De SDK-documentatie verwijst soms naar de typen die al zijn ingebouwd in Windows Runtime en kunnen worden gebruikt in XAML als de XAML-woordenlijst voor de Windows Runtime. Met Microsoft Visual Studio kunt u markeringen produceren die geldig zijn binnen deze XAML-woordenlijst. Visual Studio kan ook uw aangepaste typen voor XAML-gebruik bevatten, zolang in het project naar de bron van deze typen wordt verwezen. Zie XAML-naamruimten en naamruimtetoewijzingen voor meer informatie over XAML en aangepaste typen.

Objecten declareren

Programmeurs denken vaak aan objecten en leden, terwijl een opmaaktaal wordt geconceptualiseerd als elementen en kenmerken. In de meest elementaire zin wordt een element dat u declareert in XAML-markeringen een object in een backing runtime-objectweergave. Als u een runtimeobject voor uw app wilt maken, declareert u een XAML-element in de XAML-markering. Het object wordt gemaakt wanneer de Windows Runtime uw XAML laadt.

Een XAML-bestand heeft altijd precies één element dat fungeert als de hoofdmap, die een object declareert dat de conceptuele hoofdmap van een bepaalde programmeerstructuur is, zoals een pagina, of de objectgrafiek van de volledige runtimedefinitie van een toepassing.

In termen van XAML-syntaxis zijn er drie manieren om objecten in XAML te declareren:

  • Rechtstreeks met behulp van de syntaxis van het objectelement: Hierbij wordt gebruikgemaakt van het openen en sluiten van tags om een object te instantiëren als een XML-formulierelement. U kunt deze syntaxis gebruiken om hoofdobjecten te declareren of geneste objecten te maken die eigenschapswaarden instellen.
  • Indirect, met behulp van kenmerksyntaxis: Hiermee wordt een inlinetekenreekswaarde gebruikt die instructies bevat voor het maken van een object. De XAML-parser gebruikt deze tekenreeks om de waarde van een eigenschap in te stellen op een zojuist gemaakte referentiewaarde. Ondersteuning hiervoor is beperkt tot bepaalde algemene objecten en eigenschappen.
  • Een markeringsextensie gebruiken.

Dit betekent niet dat u altijd de keuze hebt uit een syntaxis voor het maken van objecten in een XAML-woordenlijst. Sommige objecten kunnen alleen worden gemaakt met behulp van de syntaxis van objectelementen. Sommige objecten kunnen alleen worden gemaakt door in eerste instantie in een kenmerk in te stellen. In feite zijn objecten die kunnen worden gemaakt met objectelement- of attribuutsyntaxis relatief zelden in XAML-vocabularia. Zelfs als beide syntaxisformulieren mogelijk zijn, komt een van de syntaxis vaker voor als een kwestie van stijl. Er zijn ook technieken die u in XAML kunt gebruiken om te verwijzen naar bestaande objecten in plaats van nieuwe waarden te maken. De bestaande objecten kunnen worden gedefinieerd in andere gebieden van XAML of bestaan impliciet via een bepaald gedrag van het platform en de bijbehorende toepassings- of programmeermodellen.

Een object declareren met behulp van de syntaxis van het objectelement

Als u een object met de syntaxis van het objectelement wilt declareren, schrijft u tags als volgt: <objectName> </objectName>, waarbij objectNaam de typenaam is voor het object dat u wilt instantiëren. Hier ziet u het gebruik van objectelementen om een Canvas-object te declareren:

<Canvas>
</Canvas>

Als het object geen andere objecten bevat, kunt u het objectelement declareren met behulp van één zelfsluitende tag in plaats van een openings-/sluitend paar: <Canvas />

Containers

Veel objecten die worden gebruikt als UI-elementen, zoals Canvas, kunnen andere objecten bevatten. Deze worden soms containers genoemd. In het volgende voorbeeld ziet u een Canvas-container met één element, een rechthoek.

<Canvas>
  <Rectangle />
</Canvas>

Een object declareren met behulp van de syntaxis van het kenmerk

Omdat dit gedrag is gekoppeld aan de instelling van eigenschappen, bespreken we dit in toekomstige secties.

Initialisatietekst

Voor sommige objecten kunt u nieuwe waarden declareren met behulp van binnenste tekst die wordt gebruikt als initialisatiewaarden voor constructie. In XAML wordt deze techniek en syntaxis initialisatietekst genoemd. Conceptueel is initialisatietekst vergelijkbaar met het aanroepen van een constructor met parameters. Initialisatietekst is handig voor het instellen van initiële waarden van bepaalde structuren.

U gebruikt vaak een syntaxis van een objectelement met initialisatietekst als u een structuurwaarde met een x:Key wilt, zodat deze in een ResourceDictionary kan bestaan. U kunt dit doen als u die structuurwaarde deelt tussen meerdere doeleigenschappen. Voor sommige structuren kunt u geen kenmerksyntaxis gebruiken om de waarden van de structuur in te stellen: initialisatietekst is de enige manier om een nuttige en deelbare CornerRadius-, Dikte-, GridLength - of Color-resource te produceren.

In dit verkorte voorbeeld wordt initialisatietekst gebruikt om waarden op te geven voor een dikte, in dit geval het opgeven van waarden die zowel van links als van rechts naar 20 en zowel boven als onder 10 zijn ingesteld. In dit voorbeeld ziet u de dikte die is gemaakt als een sleutelresource en vervolgens de verwijzing naar die resource. Voor meer informatie over de initialisatietekst van Dikte, zie Dikte.

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

Opmerking

Sommige structuren kunnen niet worden gedeclareerd als objectelementen. Initialisatietekst wordt niet ondersteund en kan niet worden gebruikt als bron. U moet een kenmerksyntaxis gebruiken om eigenschappen in te stellen op deze waarden in XAML. Deze typen zijn: Duur, RepeatBehavior, Punt, Rect en Grootte.

Eigenschappen instellen

U kunt eigenschappen instellen voor objecten die u hebt gedeclareerd met behulp van de syntaxis van het objectelement. Er zijn meerdere manieren om eigenschappen in te stellen in XAML:

  • Door kenmerkensyntaxis te gebruiken.
  • Door de syntaxis van het eigenschapselement te gebruiken.
  • Door de elementsyntaxis te gebruiken waarbij de inhoud (interne tekst of onderliggende elementen) de eigenschap XAML-inhoud van een object instelt.
  • Met behulp van een verzamelingssyntaxis (dit is meestal de impliciete verzamelingsyntaxis).

Net als bij objectdeclaratie impliceert deze lijst niet dat een eigenschap kan worden ingesteld met elk van de technieken. Sommige eigenschappen ondersteunen slechts een van de technieken. Sommige eigenschappen ondersteunen meer dan één formulier; Er zijn bijvoorbeeld eigenschappen die de syntaxis van het eigenschapselement of de syntaxis van het kenmerk kunnen gebruiken. Wat er mogelijk is, is afhankelijk van de eigenschap en het objecttype dat door de eigenschap wordt gebruikt. In de naslaginformatie over de Windows Runtime-API kunt u de XAML-toepassingen bekijken die beschikbaar zijn in de sectie Syntaxis. Soms is er een alternatief gebruik dat zou werken, maar uitgebreider zou zijn. Deze uitgebreide gebruiksgegevens worden niet altijd weergegeven, omdat we u de aanbevolen procedures of de praktijkscenario's voor het gebruik van die eigenschap in XAML proberen te tonen. Richtlijnen voor de XAML-syntaxis vindt u in de secties XAML-gebruik van referentiepagina's voor eigenschappen die kunnen worden ingesteld in XAML.

Sommige eigenschappen op objecten kunnen op geen enkele manier in XAML worden ingesteld en kunnen alleen worden ingesteld met behulp van code. Meestal zijn dit eigenschappen die geschikter zijn om mee te werken in de code-behind, niet in XAML.

Een alleen-lezen eigenschap kan niet worden ingesteld in XAML. Zelfs in code moet het type eigenaar een andere manier ondersteunen om het in te stellen, zoals een overbelasting van een constructor, helpermethode of ondersteuning voor berekende eigenschappen. Een berekende eigenschap is afhankelijk van de waarden van andere settabeleigenschappen plus soms een gebeurtenis met ingebouwde verwerking; deze functies zijn beschikbaar in het afhankelijkheidseigenschapssysteem. Zie het overzicht van eigenschappen van afhankelijkheden voor meer informatie over hoe afhankelijkheidseigenschappen nuttig zijn voor ondersteuning van berekende eigenschappen.

De syntaxis van verzamelingen in XAML doet het voorkomen alsof u een alleen-lezen eigenschap configureert, maar in feite is dat niet zo. Zie 'Syntaxis van verzameling' verderop in dit onderwerp.

Een eigenschap instellen met behulp van kenmerksyntaxis

Het instellen van een kenmerkwaarde is de gebruikelijke methode waarmee u een eigenschapswaarde instelt in een opmaaktaal, bijvoorbeeld in XML of HTML. Het instellen van XAML-kenmerken is vergelijkbaar met de manier waarop u kenmerkwaarden instelt in XML. De kenmerknaam wordt opgegeven op elk punt binnen de tags na de elementnaam, gescheiden van elementnaam door ten minste één witruimte. De kenmerknaam wordt gevolgd door een gelijkteken. De kenmerkwaarde bevindt zich in een paar aanhalingstekens. De aanhalingstekens kunnen enkele of dubbele aanhalingstekens zijn, zolang ze identiek zijn en de waarde insluiten. De kenmerkwaarde zelf moet worden weergegeven als een tekenreeks. De tekenreeks bevat vaak cijfers, maar voor XAML zijn alle kenmerkwaarden tekenreekswaarden totdat de XAML-parser wordt betrokken en een aantal eenvoudige waardeconversies wordt uitgevoerd.

In dit voorbeeld wordt de kenmerksyntaxis voor vier kenmerken gebruikt om de eigenschappen Naam, Breedte, Hoogte en Opvulling van een rechthoekobject in te stellen.

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

Een eigenschap instellen met behulp van de syntaxis van het eigenschapselement

Veel eigenschappen van een object kunnen worden ingesteld met behulp van de syntaxis van het eigenschapselement. Een eigenschapselement ziet er als volgt uit: <objecteigenschap.>.

Als u de syntaxis van het eigenschapselement wilt gebruiken, maakt u XAML-eigenschapselementen voor de eigenschap die u wilt instellen. In standaard-XML wordt dit element beschouwd als een element met een punt in de naam. In XAML identificeert de punt in de elementnaam het element echter als een eigenschapselement, waarbij de eigenschap naar verwachting lid is van het object in een implementatie van het backing-objectmodel. Als u de syntaxis van het eigenschapselement wilt gebruiken, moet u een objectelement kunnen opgeven om de eigenschapselementtags te vullen. Een eigenschapselement heeft altijd bepaalde inhoud (één element, meerdere elementen of binnenste tekst); Het heeft geen zin om een eigenschapselement voor zichzelf te sluiten.

In de volgende grammatica is de eigenschap de naam van de eigenschap die u wilt instellen en eigenschapValueAsObjectElement is een enkel objectelement dat naar verwachting voldoet aan de waardetypevereisten van de eigenschap.

< object>

< object.eigenschap>

propertyValueAsObjectElement

</ object.eigenschap>

</ object>

In het volgende voorbeeld wordt de syntaxis van het eigenschapselement gebruikt om de Fill van een Rectangle in te stellen met een SolidColorBrush-objectelement. (Binnen de SolidColorBrush is Color ingesteld als een kenmerk.) Het geparseerde resultaat van deze XAML is identiek aan het vorige XAML-voorbeeld dat Fill instelt met behulp van de syntaxis van het kenmerk.

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

XAML-woordenlijsten en objectgeoriënteerde programmering

Eigenschappen en gebeurtenissen die worden weergegeven als XAML-leden van een Windows Runtime XAML-type, worden vaak overgenomen van basistypen. Bekijk dit voorbeeld: <Button Background="Blue" .../>. De eigenschap Achtergrond is geen onmiddellijk gedeclareerde eigenschap in de knopklasse . In plaats daarvan wordt Achtergrond overgenomen van de basisbeheerklasse . Als u het naslagonderwerp voor De knop bekijkt, ziet u dat de ledenlijsten ten minste één overgenomen lid van elk van een keten van opeenvolgende basisklassen bevatten: ButtonBase, Control, FrameworkElement, UIElement, DependencyObject. In de lijst Eigenschappen worden alle lees/schrijfeigenschappen en verzamelingseigenschappen overgenomen in de zin van een XAML-woordenschat. Gebeurtenissen (zoals de verschillende UIElement-gebeurtenissen ) worden ook overgenomen.

Als u de Windows Runtime-verwijzing voor XAML-richtlijnen gebruikt, is de elementnaam die wordt weergegeven in een syntaxis of zelfs in voorbeeldcode soms voor het type dat de eigenschap oorspronkelijk definieert, omdat dat referentieonderwerp wordt gedeeld door alle mogelijke typen die deze overnemen van een basisklasse. Als u De IntelliSense voor XAML van Visual Studio in de XML-editor gebruikt, doen de IntelliSense en de bijbehorende vervolgkeuzelijsten een uitstekende taak om de overname samen te stellen en een nauwkeurige lijst met kenmerken op te geven die beschikbaar zijn voor instelling zodra u met een objectelement voor een klasse-exemplaar bent begonnen.

XAML-inhoudseigenschappen

Sommige typen definiëren een van hun eigenschappen, zodat de eigenschap een XAML-inhoudsyntaxis mogelijk maakt. Voor de inhoudseigenschap XAML van een type kunt u het eigenschapselement voor die eigenschap weglaten bij het opgeven ervan in XAML. U kunt de eigenschap ook instellen op een interne tekstwaarde door die interne tekst rechtstreeks binnen de objectelement-tags van het type waarvan het eigenaar is op te geven. XAML-inhoudseigenschappen ondersteunen eenvoudige opmaaksyntaxis voor die eigenschap en maakt de XAML beter leesbaar door het nesten te verminderen.

Als er een syntaxis voor XAML-inhoud beschikbaar is, wordt die syntaxis weergegeven in de secties XAML van syntaxis voor die eigenschap in de referentiedocumentatie van Windows Runtime. Op de pagina Kind eigenschap voor Rand wordt bijvoorbeeld de syntaxis van XAML-inhoud weergegeven in plaats van de syntaxis van het eigenschapselement om de enkelvoudige-objectwaarde Border.Child van een Rand in te stellen, zoals:

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

Als de eigenschap die is gedeclareerd als de XAML-inhoudseigenschap het type Object of String is, ondersteunt de syntaxis van de XAML-inhoud wat in feite binnenste tekst in het XML-documentmodel is: een tekenreeks tussen de openings- en sluitende objecttags. Op de pagina Teksteigenschap voor TextBlock wordt bijvoorbeeld de syntaxis van XAML-inhoud weergegeven die een binnenste tekstwaarde heeft om Tekst in te stellen, maar de tekenreeks 'Tekst' wordt nooit weergegeven in de opmaak. Hier volgt een voorbeeld van het gebruik:

<TextBlock>Hello!</TextBlock>

Als er een XAML-inhoudseigenschap bestaat voor een klasse, die wordt aangegeven in het naslagonderwerp voor de klasse, in de sectie Kenmerken. Zoek naar de waarde van ContentPropertyAttribute. Dit kenmerk maakt gebruik van een benoemd veld 'Naam'. De waarde van "Name" is de naam van de eigenschap van die klasse die de XAML-inhoudseigenschap is. Op de Border-referentie pagina ziet u bijvoorbeeld: ContentProperty("Name=Child").

Een belangrijke XAML-syntaxisregel die we moeten vermelden, is dat u de XAML-inhoudseigenschap en andere eigenschapselementen die u voor het element hebt ingesteld, niet kunt intermixen. De inhoudseigenschap van XAML moet volledig worden ingesteld vóór alle eigenschapselementen, of volledig daarna. Dit is bijvoorbeeld ongeldig XAML:

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

Verzamelingssyntaxis

Alle syntaxisen die tot nu toe worden weergegeven, zijn het instellen van eigenschappen op afzonderlijke objecten. Voor veel UI-scenario's is vereist echter dat een gegeven bovenliggend element meerdere onderliggende elementen kan bevatten. Een gebruikersinterface voor een invoerformulier heeft bijvoorbeeld verschillende tekstvakelementen, sommige labels en misschien een knop Verzenden nodig. Als u echter een programmeerobjectmodel zou gebruiken om toegang te krijgen tot deze meerdere elementen, zouden ze meestal items in één verzamelingseigenschap zijn, in plaats van elk item de waarde van verschillende eigenschappen te zijn. XAML ondersteunt meerdere subelementen en een typisch ondersteunend verzamelingsmodel door eigenschappen die een verzamelingstype als impliciet gebruiken te behandelen, en bijzondere verwerking uit te voeren voor subelementen van een verzamelingstype.

Veel verzamelingseigenschappen worden ook geïdentificeerd als de XAML-inhoudseigenschap voor de klasse. De combinatie van impliciete verzamelingsverwerking en XAML-inhoudssyntaxis wordt vaak gezien in typen die worden gebruikt voor controlecompositing, zoals panelen, weergaven of itemsbesturingselementen. In het volgende voorbeeld ziet u bijvoorbeeld de eenvoudigste mogelijke XAML voor het composieren van twee peer-UI-elementen in een StackPanel.

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

Het mechanisme van de XAML-verzamelingssyntaxis

Het kan in eerste instantie lijken dat XAML een 'instellen' mogelijk maakt van de eigenschap alleen-lezen-verzameling. Wat XAML hier mogelijk maakt, is het toevoegen van items aan een bestaande verzameling. De XAML-taal en XAML-processors die XAML-ondersteuning implementeren, zijn afhankelijk van een conventie in onderliggende verzamelingstypen om deze syntaxis te ondersteunen. Normaal gesproken is er een back-upeigenschap, zoals een indexeerfunctie of eigenschap Items die verwijst naar specifieke items van de verzameling. Over het algemeen is deze eigenschap niet expliciet in de XAML-syntaxis. Voor verzamelingen is het onderliggende mechanisme voor XAML parseren geen eigenschap, maar een methode: in de meeste gevallen de methode Toevoegen . Wanneer de XAML-processor een of meer objectelementen binnen een XAML-verzamelingsyntaxis tegenkomt, wordt elk object eerst vanuit een element aangemaakt, waarna elk nieuw object achtereenvolgens aan de collectie wordt toegevoegd door de Toevoegen-methode van de collectie aan te roepen.

Wanneer een XAML-parser items toevoegt aan een verzameling, is het de logica van de methode Toevoegen die bepaalt of een bepaald XAML-element een toegestaan item is van het verzamelingsobject. Veel verzamelingstypen zijn sterk getypt door de achterliggende implementatie, wat betekent dat de parameter van Add verwacht dat wat wordt doorgegeven moet overeenkomen met het parametertype van Add.

Let bij verzamelingseigenschappen op wanneer u de verzameling expliciet als objectelement probeert op te geven. Een XAML-parser maakt een nieuw object wanneer er een objectelement wordt aangeroepen. Als de verzamelingseigenschap die u probeert te gebruiken alleen-lezen is, kan dit een XAML-parse-exceptie veroorzaken. Gebruik alleen de syntaxis van de impliciete verzameling en u ziet die uitzondering niet.

Wanneer moet u de syntaxis van het kenmerk of eigenschapselement gebruiken

Alle eigenschappen die in XAML kunnen worden ingesteld, ondersteunen de syntaxis van kenmerken of eigenschappensyntaxis voor het direct instellen van waarden, maar ondersteunen mogelijk niet beide syntaxisvormen door elkaar. Sommige eigenschappen ondersteunen beide syntaxis en sommige eigenschappen ondersteunen aanvullende syntaxisopties, zoals een XAML-inhoudseigenschap. Het type XAML-syntaxis dat door een eigenschap wordt ondersteund, is afhankelijk van het type object dat door de eigenschap wordt gebruikt als het eigenschapstype. Als het eigenschapstype een primitief type is, zoals een dubbele waarde (zwevend of decimaal), geheel getal, Booleaanse waarde of tekenreeks, ondersteunt de eigenschap altijd de syntaxis van het kenmerk.

U kunt ook de syntaxis van het kenmerk gebruiken om een eigenschap in te stellen als het objecttype dat u gebruikt om die eigenschap in te stellen, kan worden gemaakt door een tekenreeks te verwerken. Voor primitieven is dit altijd het geval, de typeconversie is ingebouwd in de parser. Bepaalde andere objecttypen kunnen echter ook worden gemaakt met behulp van een tekenreeks die is opgegeven als een kenmerkwaarde, in plaats van een objectelement in een eigenschapselement. Dit werkt alleen als er een onderliggende typeconversie moet zijn, die wordt ondersteund door die specifieke eigenschap of in het algemeen wordt ondersteund voor alle waarden die gebruikmaken van dat eigenschapstype. De tekenreekswaarde van het kenmerk wordt gebruikt om eigenschappen in te stellen die belangrijk zijn voor de initialisatie van de nieuwe objectwaarde. Mogelijk kan een specifieke typeconverter ook verschillende subklassen van een gemeenschappelijk kenmerkentype maken, afhankelijk van hoe deze informatie in de tekenreeks uniek verwerkt. Objecttypen die dit gedrag ondersteunen, hebben een speciale grammatica die wordt vermeld in de syntaxissectie van de referentiedocumentatie. De XAML-syntaxis voor Brush laat bijvoorbeeld zien hoe een kenmerksyntaxis kan worden gebruikt om een nieuwe SolidColorBrush-waarde te maken voor elke eigenschap van het type Brush (en er zijn veel kwasteigenschappen in Windows Runtime XAML).

XAML-parseringslogica en -regels

Soms is het leerzaam om de XAML te lezen zoals een XAML-parser dat doet: als een set van tekenreekstokens die in een lineaire volgorde zijn opgenomen. Een XAML-parser moet deze tokens interpreteren onder een set regels die deel uitmaken van de definitie van hoe XAML werkt.

Het instellen van een kenmerkwaarde is de gebruikelijke methode waarmee u een eigenschapswaarde instelt in een opmaaktaal, bijvoorbeeld in XML of HTML. In de volgende syntaxis is objectName het object dat u wilt instantiëren, eigenschapName is de naam van de eigenschap die u wilt instellen voor dat object en eigenschapValue is de waarde die u wilt instellen.

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

-or-

<objectName propertyName="propertyValue">

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

</objectName>

Met beide syntaxis kunt u een object declareren en een eigenschap voor dat object instellen. Hoewel het eerste voorbeeld één element in markeringen is, zijn er hier eigenlijk discrete stappen met betrekking tot de wijze waarop een XAML-processor deze markering parseert.

Ten eerste geeft de aanwezigheid van het objectelement aan dat een nieuw objectName-object moet worden geïnstantieerd. Pas nadat een dergelijk exemplaar bestaat, kan de eigenschap PropertyName van het exemplaar erop worden ingesteld.

Een andere regel van XAML is dat kenmerken van een element in elke volgorde moeten kunnen worden ingesteld. Er is bijvoorbeeld geen verschil tussen <Rectangle Height="50" Width="100" /> en <Rectangle Width="100" Height="50" />. Welke volgorde u gebruikt, is een kwestie van stijl.

Opmerking

XAML-ontwerpers bevorderen vaak bestelconventies als u andere ontwerpoppervlakken dan de XML-editor gebruikt, maar u kunt die XAML later vrij bewerken om de kenmerken opnieuw te ordenen of nieuwe te introduceren.

Gekoppelde eigenschappen

XAML breidt XML uit door een syntaxiselement toe te voegen dat een gekoppelde eigenschap wordt genoemd. Net als bij de syntaxis van het eigenschapselement bevat de gekoppelde eigenschapsyntaxis een punt en bevat de punt speciale betekenis voor XAML-parsering. Met name de punt scheidt de provider van de gekoppelde eigenschap en de naam van de eigenschap.

In XAML stelt u gekoppelde eigenschappen in met behulp van de syntaxis AttachedPropertyProvider. PropertyName Hier volgt een voorbeeld van hoe u de gekoppelde eigenschap Canvas.Left kunt instellen in XAML:

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

U kunt de gekoppelde eigenschap instellen op elementen die geen eigenschap van die naam hebben in het backingtype en op die manier werken ze enigszins als een globale eigenschap of een kenmerk dat is gedefinieerd door een andere XML-naamruimte, zoals het kenmerk xml:space .

In Windows Runtime XAML ziet u gekoppelde eigenschappen die ondersteuning bieden voor deze scenario's:

Zie Het overzicht van bijgevoegde eigenschappen voor meer informatie.

Letterlijke {-waarden

Omdat het accolaad-openingssymbool { het begin aangeeft van de opmaakuitbreidingsreeks, gebruikt u een escapesequentie om een letterlijke tekenreekswaarde op te geven die begint met "{". De escape-sequentie is "{}". Als u bijvoorbeeld een tekenreekswaarde wilt opgeven die een enkele openingsaccolade is, geef dan de kenmerkwaarde op als "{}{". U kunt ook de alternatieve aanhalingstekens (bijvoorbeeld een ' binnen een kenmerkwaarde gescheiden door '') gebruiken om een {-waarde als een tekenreeks op te geven.

Opmerking

\} werkt ook als dit zich in een geciteerd attribuut bevindt.  

Opsommingswaarden

Veel eigenschappen in de Windows Runtime-API gebruiken opsommingen als waarden. Als het lid een lees-schrijf eigenschap is, kunt u een dergelijke eigenschap instellen door een attribuutwaarde op te geven. U bepaalt welke opsommingswaarde moet worden gebruikt als de waarde van de eigenschap door de niet-gekwalificeerde naam van de constante te gebruiken. U kunt bijvoorbeeld UIElement.Visibility instellen in XAML: <Button Visibility="Visible"/>. Hier wordt 'Visible' als tekenreeks rechtstreeks toegewezen aan een benoemde constante van de opsomming Visibility, Visible.

  • Gebruik geen gekwalificeerde vorm, dit werkt niet. Dit is bijvoorbeeld ongeldig XAML: <Button Visibility="Visibility.Visible"/>.
  • Gebruik de waarde van de constante niet. Met andere woorden, vertrouw niet op de gehele waarde van de opsomming die er expliciet of impliciet is, afhankelijk van hoe de opsomming is gedefinieerd. Hoewel het lijkt te werken, is het een slechte gewoonte in XAML of in code omdat u vertrouwt op wat een tijdelijke implementatiedetail kan zijn. Doe dit bijvoorbeeld niet: <Button Visibility="1"/>.

Opmerking

In naslagonderwerpen voor API's die gebruikmaken van XAML en opsommingen gebruiken, klikt u op de koppeling naar het opsommingstype in de sectie Eigenschapswaarde van Syntaxis. Deze koppeling verwijst naar de opsommingspagina waar u de benoemde constanten voor die opsomming kunt ontdekken.

Opsommingen kunnen vlaggewijs zijn, wat betekent dat ze worden toegeschreven aan FlagsAttribute. Als u een combinatie van waarden voor een vlaggewijze opsomming moet opgeven als een XAML-kenmerkwaarde, gebruikt u de naam van elke opsommingsconstante, met een komma (,) tussen elke naam en geen tussenliggende spatietekens. Flagwise-kenmerken zijn niet gebruikelijk in de Windows Runtime XAML-woordenlijst, maar ManipulationModes is een voorbeeld waarbij het instellen van een vlaggewijze opsommingswaarde in XAML wordt ondersteund.

Interfaces in XAML

In zeldzame gevallen ziet u een XAML-syntaxis waarbij het type eigenschap een interface is. In het XAML-typesysteem is een type dat die interface implementeert acceptabel als een waarde wanneer deze wordt geparseerd. Er moet een gemaakt exemplaar van een dergelijk type beschikbaar zijn om als waarde te fungeren. U ziet een interface die wordt gebruikt als een type in de XAML-syntaxis voor de eigenschappen Command en CommandParameter van ButtonBase. Deze eigenschappen ondersteunen model-View-ViewModel (MVVM) ontwerppatronen waarbij de ICommand-interface het contract is voor de manier waarop de weergaven en modellen communiceren.

Referentie over placeholder-conventies voor XAML in Windows Runtime

Als u een van de sectie Syntaxis van naslagonderwerpen hebt onderzocht voor Windows Runtime-API's die XAML kunnen gebruiken, hebt u waarschijnlijk gezien dat de syntaxis nogal wat tijdelijke aanduidingen bevat. De XAML-syntaxis verschilt van de syntaxis van C#, Microsoft Visual Basic of van de uitbreidingen voor Visual C++ componenten (C++/CX), omdat de XAML-syntaxis een gebruik-syntaxis is. Het is een hint voor uw uiteindelijke gebruik in uw eigen XAML-bestanden, maar zonder over-prescriptief te zijn over de waarden die u kunt gebruiken. Meestal beschrijft het gebruik dus een type grammatica dat letterlijke waarden en tijdelijke aanduidingen combineert en enkele van de tijdelijke aanduidingen in de sectie XAML-waarden definieert.

Wanneer u typnamen/elementnamen in een XAML-syntaxis voor een eigenschap ziet, is de weergegeven naam voor het type dat de eigenschap oorspronkelijk definieert. Windows Runtime XAML ondersteunt echter een model voor de overname van klassen op basis van DependencyObject. U kunt dus vaak een kenmerk gebruiken voor een klasse die niet letterlijk de definitieklasse is, maar in plaats daarvan is afgeleid van een klasse die de eigenschap/het kenmerk voor het eerst heeft gedefinieerd. U kunt bijvoorbeeld Zichtbaarheid instellen als een kenmerk voor elke afgeleide UIElement-klasse met behulp van een diepe overname. Voorbeeld: <Button Visibility="Visible" />. Neem dus niet de elementnaam die wordt weergegeven in een XAML-gebruiksyntaxis letterlijk; de syntaxis kan geschikt zijn voor elementen die die klasse vertegenwoordigen en ook elementen die een afgeleide klasse vertegenwoordigen. In gevallen waarin het zelden of onmogelijk is dat het type dat wordt weergegeven als het definiërende element in een praktische toepassing voorkomt, wordt die typenaam opzettelijk in kleine letters geschreven in de syntaxis. De syntaxis die u ziet voor UIElement.Visibility is bijvoorbeeld:

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

Veel XAML-syntaxissecties bevatten tijdelijke aanduidingen in de sectie 'Gebruik' die vervolgens worden gedefinieerd in een sectie XAML-waarden die zich direct onder de sectie Syntaxis bevinden.

In XAML-gebruikssecties worden ook verschillende gegeneraliseerde tijdelijke aanduidingen gebruikt. Deze tijdelijke aanduidingen worden niet elke keer opnieuw gedefinieerd in XAML-waarden, omdat u waarschijnlijk of uiteindelijk leert wat ze vertegenwoordigen. We denken dat de meeste lezers het zat zouden worden om ze steeds weer in XAML-waarden te zien, dus hebben we ze weggelaten uit de definities. Ter referentie: hier volgt een lijst met enkele van deze tijdelijke aanduidingen en wat ze betekenen in algemene zin:

  • object: theoretisch elke objectwaarde, maar vaak praktisch beperkt tot bepaalde typen objecten, zoals een tekenreeks- of objectkeuze, en controleer de opmerkingen op de referentiepagina voor meer informatie.
  • objecteigenschap: objecteigenschap in combinatie wordt gebruikt voor gevallen waarin de weergegeven syntaxis de syntaxis is voor een type dat kan worden gebruikt als een kenmerkwaarde voor veel eigenschappen. Het Xaml-kenmerkgebruik dat wordt weergegeven voor Brush bevat bijvoorbeeld: <objectproperty="predefinedColorName"/>
  • eventhandler: dit wordt weergegeven als de kenmerkwaarde voor elke XAML-syntaxis die wordt weergegeven voor een gebeurteniskenmerk. Wat u hier opgeeft, is de functienaam voor een gebeurtenis-handlerfunctie. Deze functie moet in de code-behind van de XAML-pagina worden gedefinieerd. Op programmeerniveau moet die functie overeenkomen met de gedelegeerde handtekening van de gebeurtenis die u verwerkt, of uw app-code wordt niet gecompileerd. Maar dat is echt een programmeeroverweging, geen XAML-overweging, dus we proberen niets te hinten over het type gedelegeerde in de XAML-syntaxis. Als u wilt weten welke gemachtigde u moet implementeren voor een gebeurtenis, bevindt dat zich in de sectie Gebeurtenisgegevens van het referentieonderwerp voor de gebeurtenis, in een tabelrij met het label Delegate.
  • enumMemberName: weergegeven in de syntaxis van het kenmerk voor alle opsommingen. Er is een vergelijkbare placeholder voor eigenschappen die gebruikmaken van een opsommingswaarde, maar meestal wordt de placeholder voorafgegaan door een aanwijzing van de naam van de opsomming. De syntaxis die wordt weergegeven voor FrameworkElement.FlowDirection is < bijvoorbeeld frameworkElementFlowDirection="flowDirectionMemberName"/>. Als u zich op een van deze eigenschappenverwijzingspagina's bevindt, klikt u op de koppeling naar het opsommingstype dat wordt weergegeven in de sectie Eigenschapswaarde , naast het teksttype:. Voor de kenmerkwaarde van een eigenschap die gebruikmaakt van die opsomming, kunt u elke tekenreeks gebruiken die wordt vermeld in de kolom Lid van de lijst Leden .
  • double, int, string, bool: Dit zijn primitieve typen die bekend staan bij de XAML-taal. Als u programmeert met C# of Visual Basic, worden deze typen geprojecteerd naar equivalente Microsoft .NET-typen, zoals Double, Int32, String en Booleaanse waarde, en kunt u alle leden van deze .NET-typen gebruiken wanneer u met uw door XAML gedefinieerde waarden in .NET-code-behind werkt. Als u programmeert met C++/CX, gebruikt u de primitieve C++-typen, maar u kunt deze equivalenten ook beschouwen als typen die zijn gedefinieerd door de platformnaamruimte , bijvoorbeeld Platform::String. Er zijn soms aanvullende waardebeperkingen voor bepaalde eigenschappen. Maar u ziet deze meestal in een sectie Eigenschapswaarde of Opmerkingen en niet in een XAML-sectie, omdat dergelijke beperkingen van toepassing zijn op codegebruik en XAML-gebruik.

Tips en trucs, notities over stijl

  • Markeringsextensies in het algemeen worden beschreven in het hoofdoverzicht van XAML. Maar de markeringsextensie die het meest van invloed is op de richtlijnen die in dit onderwerp worden gegeven, is de staticResource-markeringsextensie (en gerelateerde ThemeResource). De functie van de staticResource-markeringsextensie is het inschakelen van factoring van uw XAML in herbruikbare resources die afkomstig zijn van een XAML ResourceDictionary. U definieert bijna altijd besturingssjablonen en gerelateerde stijlen in een ResourceDictionary. U definieert vaak ook de kleinere onderdelen van een definitie van een besturingssjabloon of app-specifieke stijl in een ResourceDictionary , bijvoorbeeld een SolidColorBrush voor een kleur die uw app meer dan één keer gebruikt voor verschillende onderdelen van de gebruikersinterface. Met behulp van een StaticResource kan elke eigenschap waarvoor anders het gebruik van een eigenschapselement moet worden ingesteld, nu worden ingesteld in de syntaxis van het kenmerk. Maar de voordelen van factoring XAML voor hergebruik gaan verder dan alleen het vereenvoudigen van de syntaxis op paginaniveau. Zie ResourceDictionary- en XAML-resourceverwijzingen voor meer informatie.
  • U ziet verschillende conventies voor hoe witruimte en regelfeeds worden toegepast in XAML-voorbeelden. Er zijn met name verschillende conventies voor het opsplitsen van objectelementen die veel verschillende kenmerken hebben ingesteld. Dat is gewoon een kwestie van stijl. In de XML-editor van Visual Studio worden enkele standaardstijlregels toegepast wanneer u XAML bewerkt, maar u kunt deze wijzigen in de instellingen. Er zijn een klein aantal gevallen waarin de witruimte in een XAML-bestand als significant wordt beschouwd; Zie XAML en witruimte voor meer informatie.
  • Last updated on