Dela via

XAML-syntaxguide

Vi förklarar XAML-syntaxregler och den terminologi som beskriver de begränsningar eller val som är tillgängliga för XAML-syntax. Det här avsnittet är användbart om du är nybörjare på att använda XAML-språket, om du vill ha en uppdatering av terminologin eller delar av syntaxen, eller om du är nyfiken på hur XAML-språket fungerar och vill ha mer bakgrund och kontext.

XAML är XML

XAML (Extensible Application Markup Language) har en grundläggande syntax som bygger på XML, och per definition måste giltig XAML vara giltig XML. Men XAML har också egna syntaxbegrepp som utökar XML. En viss XML-entitet kan vara giltig i vanlig XML, men den syntaxen kan ha en annan och mer fullständig betydelse som XAML. I det här avsnittet beskrivs dessa XAML-syntaxbegrepp.

XAML-vokabulärer

Ett område där XAML skiljer sig från de flesta XML-användningar är att XAML vanligtvis inte tillämpas med ett schema, till exempel en XSD-fil. Det beror på att XAML är avsett att vara utökningsbart, det är vad "X" i förkortningen XAML betyder. När XAML har parsats förväntas de element och attribut som du refererar till i XAML finnas i viss återgivning av kod, antingen i de kärntyper som definierats av Windows Runtime eller i typer som utökar eller baseras på Windows Runtime. SDK-dokumentationen refererar ibland till de typer som redan är inbyggda i Windows Runtime och kan användas i XAML som XAML-vokabulär för Windows Runtime. Microsoft Visual Studio hjälper dig att skapa markering som är giltig i den här XAML-vokabulären. Visual Studio kan också inkludera dina anpassade typer för XAML-användning så länge källan till dessa typer refereras korrekt i projektet. Mer information om XAML och anpassade typer finns i XAML-namnområden och namnområdesmappning.

Deklarera objekt

Programmerare tänker ofta i termer av objekt och medlemmar, medan ett påläggsspråk konceptualiseras som element och attribut. I den mest grundläggande bemärkelsen blir ett element som du deklarerar i XAML-syntax ett objekt i en bakomliggande runtime-objektrepresentation. Om du vill skapa ett körningstidobjekt för din app, deklarerar du ett XAML-element i XAML-markering. Objektet skapas när Windows Runtime läser in din XAML.

En XAML-fil har alltid exakt ett element som fungerar som rot, vilket deklarerar ett objekt som kommer att vara den konceptuella roten i en viss programmeringsstruktur, till exempel en sida, eller objektdiagrammet för hela körningsdefinitionen för ett program.

När det gäller XAML-syntax finns det tre sätt att deklarera objekt i XAML:

  • Direkt, med hjälp av objektelementsyntax: Detta använder inledande och avslutande taggar för att instansiera ett objekt som ett XML-formulärelement. Du kan använda den här syntaxen för att deklarera rotobjekt eller för att skapa kapslade objekt som anger egenskapsvärden.
  • Indirekt med hjälp av attributsyntax: Detta använder ett infogat strängvärde som innehåller instruktioner för hur du skapar ett objekt. XAML-parsern använder den här strängen för att ange värdet för en egenskap till ett nyligen skapat referensvärde. Stöd för det är begränsat till vissa vanliga objekt och egenskaper.
  • Använda ett tillägg för markering.

Det innebär inte att du alltid har val av syntax för att skapa objekt i ett XAML-ordförråd. Vissa objekt kan bara skapas med hjälp av objektelementsyntax. Vissa objekt kan bara skapas genom att först anges i ett attribut. I själva verket är objekt som kan skapas med antingen objektelement eller attributsyntax jämförelsevis sällsynta i XAML-vokabulärer. Även om båda syntaxformulären är möjliga är en av syntaxerna vanligare när det gäller stil. Det finns också tekniker som du kan använda i XAML för att referera till befintliga objekt i stället för att skapa nya värden. De befintliga objekten kan definieras antingen inom andra områden i XAML eller kan finnas implicit genom något beteende för plattformen och dess program- eller programmeringsmodeller.

Deklarera ett objekt med hjälp av objektelementsyntax

Om du vill deklarera ett objekt med objektelementsyntax skriver du taggar så här: <objectName> </objectName>, där objectName är typnamnet för det objekt som du vill instansiera. Här är användningen av objektkontrollen för att deklarera ett Canvas-objekt:

<Canvas>
</Canvas>

Om objektet inte innehåller andra objekt kan du deklarera objektelementet med hjälp av en självslutande tagg i stället för ett inledande/avslutande par: <Canvas />

Containers

Många objekt som används som gränssnittselement, till exempel Arbetsyta, kan innehålla andra objekt. Dessa kallas ibland containrar. I följande exempel visas en Canvas som innehåller ett element, en Rectangle.

<Canvas>
  <Rectangle />
</Canvas>

Deklarera ett objekt med hjälp av attributsyntax

Eftersom detta beteende är kopplat till inställningen av egenskaper, kommer vi att prata mer om det i de kommande avsnitten.

Initieringstext

För vissa objekt kan du deklarera nya värden med hjälp av inre text som används som initieringsvärden för konstruktion. I XAML kallas den här tekniken och syntaxen för initieringstext. Konceptuellt liknar initieringstexten en konstruktor som har parametrar. Initieringstext är användbart för att ange inledande värden för vissa strukturer.

Du använder ofta en objektelementsyntax med initieringstext om du vill ha ett strukturvärde med en x:Key, så att det kan finnas i en ResourceDictionary. Du kan göra detta om du delar strukturvärdet mellan flera mål. För vissa strukturer kan du inte använda attributsyntax för att ange strukturens värden: initieringstext är det enda sättet att skapa en användbar och delbar Resurs för CornerRadius, Tjocklek, GridLength eller Färg .

I det här förkortade exemplet används initieringstext för att ange värden för en tjocklek, i det här fallet anger du värden som anger både vänster och höger till 20 och både över- och nederkant till 10. Det här exemplet visar tjockleken som skapats som en nyckelresurs och sedan referensen till den resursen. Mer information om tjockleksinitieringstext finns i Tjocklek.

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

Anmärkning

Vissa strukturer kan inte deklareras som objektelement. Initieringstext stöds inte och de kan inte användas som resurser. Du måste använda en attributsyntax för att ange egenskaper till dessa värden i XAML. Dessa typer är: Duration, RepeatBehavior, Point, Rect och Size.

Ange egenskaper

Du kan ange egenskaper för objekt som du deklarerade med hjälp av objektelementsyntax. Det finns flera sätt att ange egenskaper i XAML:

  • Med hjälp av attributsyntax.
  • Genom att använda syntax för egenskapselement.
  • Genom att använda elementsyntax där innehållet (inre text eller underordnade element) anger XAML-innehållsegenskapen för ett objekt.
  • Genom att använda en samlingssyntax (som vanligtvis är implicit samlingssyntax).

Precis som med objektdeklaration innebär den här listan inte att någon egenskap kan anges med var och en av teknikerna. Vissa egenskaper stöder bara en av teknikerna. Vissa egenskaper stöder mer än ett formulär. Det finns till exempel egenskaper som kan använda egenskapselementsyntax eller attributsyntax. Vad som är möjligt beror både på egenskapen och på objekttypen som egenskapen använder. I Windows Runtime API-referensen ser du de XAML-användningar som du kan använda i avsnittet Syntax . Ibland finns det en alternativ användning som skulle fungera men skulle vara mer utförlig. Dessa utförliga användningar visas inte alltid eftersom vi försöker visa bästa praxis eller verkliga scenarier för att använda den egenskapen i XAML. Vägledning för XAML-syntax finns i avsnitten XAML-användning på referenssidor för egenskaper som kan anges i XAML.

Vissa egenskaper för objekt kan inte anges i XAML på något sätt och kan bara anges med hjälp av kod. Det här är vanligtvis egenskaper som är lämpligare att arbeta med i koden bakom, inte i XAML.

Det går inte att ange en skrivskyddad egenskap i XAML. Även i kod måste ägartypen ha stöd för något annat sätt att ange den, till exempel en konstruktörsöverbelastning, hjälpmetod eller stöd för beräknade egenskaper. En beräknad egenskap förlitar sig på värdena för andra inställbara egenskaper plus ibland en händelse med inbyggd hantering. dessa funktioner är tillgängliga i beroendeegenskapssystemet. Mer information om hur beroendeegenskaper är användbara för stöd för beräknade egenskaper finns i Översikt över beroendeegenskaper.

Samlingssyntaxen i XAML ger intrycket av att du anger en skrivskyddad egenskap, men så är det inte i verkligheten. Se "Samlingssyntax" senare i det här avsnittet.

Ange en egenskap med hjälp av attributsyntax

Att ange ett attributvärde är det typiska sätt på vilket du anger ett egenskapsvärde på ett markeringsspråk, till exempel i XML eller HTML. Att ange XAML-attribut liknar hur du anger attributvärden i XML. Attributnamnet anges när som helst inom taggarna efter elementnamnet, avgränsat från elementnamnet med minst ett blanksteg. Attributnamnet följs av ett likhetstecken. Attributvärdet finns inom ett par citattecken. Citattecken kan vara antingen dubbla eller enkla, så länge de matchar och omsluter värdet. Själva attributvärdet måste vara uttrycksbart som en sträng. Strängen innehåller ofta siffror, men för XAML är alla attributvärden strängvärden tills XAML-parsern engageras och utför viss grundläggande värdekonvertering.

I det här exemplet används attributsyntax för fyra attribut för att ange egenskaperna Namn, Bredd, Höjd och Fyllning för ett rektangelobjekt .

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

Ange en egenskap med hjälp av syntax för egenskapselement

Många egenskaper för ett objekt kan anges med hjälp av syntax för egenskapselement. Ett egenskapselement ser ut så här: <objektegenskap.>.

Om du vill använda egenskapselementsyntax skapar du XAML-egenskapselement för den egenskap som du vill ange. I standard-XML skulle det här elementet bara betraktas som ett element som har en punkt i sitt namn. I XAML identifierar dock punkten i elementnamnet elementet som ett egenskapselement, där egenskapen förväntas vara medlem i objektet i en modellimplementering för säkerhetskopieringsobjekt. Om du vill använda syntax för egenskapselement måste det vara möjligt att ange ett objektelement för att kunna "fylla" egenskapselementtaggar. Ett egenskapselement har alltid en del innehåll (enstaka element, flera element eller inre text); det är ingen idé att ha ett självslutande egenskapselement.

I följande grammatik är egenskapen namnet på den egenskap som du vill ange och propertyValueAsObjectElement är ett enda objektelement som förväntas uppfylla värdetypskraven för egenskapen.

< objekt>

< objekt.egenskap>

propertyValueAsObjectElement

</ objekt.egenskap>

</ objekt>

I följande exempel används egenskapselementsyntax för att ange fyllning av en rektangel med ett SolidColorBrush-objektelement . (I SolidColorBrush anges Color som ett attribut.) Det parsade resultatet av denna XAML är identiskt med det tidigare XAML-exemplet som anger Fyllning med hjälp av attributsyntax.

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

XAML-vokabulärer och objektorienterad programmering

Egenskaper och händelser som visas som XAML-medlemmar av en Windows Runtime XAML-typ ärvs ofta från bastyper. Tänk dig det här exemplet: <Button Background="Blue" .../>. Egenskapen Background är inte en omedelbart deklarerad egenskap i klassen Button . I stället ärvs Background från baskontrollklassen . Om du tittar på referensavsnittet för Button ser du att medlemslistorna innehåller minst en ärvd medlem från var och en av en kedja med efterföljande basklasser: ButtonBase, Control, FrameworkElement, UIElement, DependencyObject. I listan Egenskaper ärvs alla skrivbara och samlingsegenskaper i XAML-vokabulär. Händelser (som de olika UIElement-händelserna ) ärvs också.

Om du använder Windows Runtime-referensen för XAML-vägledningen är elementnamnet som visas i en syntax eller till och med i exempelkoden ibland för den typ som ursprungligen definierar egenskapen, eftersom referensavsnittet delas av alla möjliga typer som ärver den från en basklass. Om du använder IntelliSense för XAML i XML-redigeraren gör IntelliSense och dess listrutor ett bra jobb med att slå samman arvet och tillhandahålla en korrekt lista över attribut som är tillgängliga för inställning när du har börjat med ett objektelement för en klassinstans.

Egenskaper för XAML-innehåll

Vissa typer definierar en av deras egenskaper så att egenskapen möjliggör en XAML-innehållssyntax. För XAML-innehållsegenskapen av en typ kan du utelämna egenskapselementet för den egenskapen när du anger den i XAML. Eller så kan du ange egenskapen till ett inre textvärde genom att ange den inre texten direkt inom ägartypens objektelementtaggar. XAML-innehållsegenskaper stöder enkel markeringssyntax för den egenskapen och gör XAML mer läsbar för människor genom att minska kapslingen.

Om en XAML-innehållssyntax är tillgänglig visas den syntaxen i avsnitten "XAML" i Syntax för den egenskapen i Windows Runtime-referensdokumentationen. Till exempel visar Child egenskapssidan för Border XAML-innehållssyntax i stället för egenskapselementsyntax för att ange Border.Child-värdet för ett enskilt objekt i en Border, så här:

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

Om egenskapen som deklareras som XAML-innehållsegenskapen är objekttypen , eller är typen Sträng, stöder XAML-innehållssyntaxen i princip inre text i XML-dokumentmodellen: en sträng mellan taggarna för att öppna och stänga objekt. Till exempel visar textegenskapssidan för TextBlock XAML-innehållssyntax som har ett inre textvärde för att ange Text, men strängen "Text" visas aldrig i markeringen. Här är ett exempel på användning:

<TextBlock>Hello!</TextBlock>

Om det finns en XAML-innehållsegenskap för en klass anges den i referensavsnittet för klassen i avsnittet "Attribut". Leta efter värdet för ContentPropertyAttribute. Det här attributet använder ett namngivet fält "Namn". Värdet "Namn" är namnet på egenskapen i klassen som är den XAML-innehållsegenskapen. På sidan Border ser du till exempel följande: ContentProperty("Name=Child").

En viktig XAML-syntaxregel som vi bör nämna är att du inte kan blanda XAML-innehållsegenskapen och andra egenskapselement som du anger för elementet. XAML-innehållsegenskapen måste anges helt före alla egenskapselement, eller helt efter. Det här är till exempel ogiltigt XAML:

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

Samlingssyntax

Alla syntaxer som visas hittills är att ställa in egenskaper på enskilda objekt. Men många användargränssnittsscenarier kräver att ett visst överordnat element kan ha flera underordnade element. Ett användargränssnitt för ett indataformulär behöver till exempel flera textruteelement, vissa etiketter och kanske en "Skicka"-knapp. Men om du skulle använda en programmeringsobjektmodell för att komma åt dessa flera element skulle de vanligtvis vara objekt i en enda samlingsegenskap, i stället för att varje objekt är värdet för olika egenskaper. XAML stöder flera underordnade element samt en typisk backande samlingsmodell genom att behandla egenskaper som använder en samlingstyp som implicita, och utföra särskild hantering för underordnade element av en samlingstyp.

Många samlingsegenskaper identifieras också som XAML-innehållsegenskap för klassen. Kombinationen av implicit insamlingsbearbetning och XAML-innehållssyntax visas ofta i typer som används för kontrollkompostering, till exempel paneler, vyer eller objektkontroller. I följande exempel visas till exempel enklast möjliga XAML för att skapa två peer-gränssnittselement i en StackPanel.

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

Mekanismen för XAML-samlingssyntax

Det kan först verka som att XAML aktiverar en "sättning" av den skrivskyddade samlingsegenskapen. I själva verket möjliggör XAML här att lägga till element i en befintlig samling. XAML-språket och XAML-processorerna som implementerar XAML-stöd förlitar sig på en konvention för att stödja samlingstyper för att aktivera den här syntaxen. Vanligtvis finns det en bakgrundsegenskap, till exempel en indexerare eller objektegenskap som refererar till specifika objekt i samlingen. I allmänhet är den egenskapen inte explicit i XAML-syntaxen. För samlingar är den underliggande mekanismen för XAML-parsning inte en egenskap, utan en metod: specifikt metoden Lägg till i de flesta fall. När XAML-processorn stöter på ett eller flera objektelement inom en XAML-samlingssyntax skapas först varje sådant objekt från ett element. Varje nytt objekt läggs till för den innehållande samlingen genom att samlingens Add-metod anropas.

När en XAML-parser lägger till objekt i en samling är det logiken i metoden Lägg till som avgör om ett visst XAML-element är ett tillåtet objekt underordnat till samlingsobjektet. Många samlingstyper är starkt typade av den underliggande implementeringen, vilket innebär att indataparametern Lägg till förväntar sig att det som skickas måste typmässigt stämma överens med Lägg till-parametertypen.

För samlingsegenskaper bör du vara försiktig när du försöker ange samlingen explicit som ett objektelement. En XAML-parser skapar ett nytt objekt när det stöter på ett objektelement. Om samlingsegenskapen som du försöker använda är skrivskyddad kan detta utlösa ett XAML-parsningsfel. Använd bara den implicita samlingssyntaxen så ser du inte det undantaget.

När du ska använda attribut- eller egenskapselementsyntax

Alla egenskaper som har stöd för att anges i XAML stöder attribut- eller egenskapselementsyntax för direktvärdesinställning, men stöder eventuellt inte någon av syntaxerna utbytbart. Vissa egenskaper stöder antingen syntax och vissa egenskaper stöder ytterligare syntaxalternativ som en XAML-innehållsegenskap. Vilken typ av XAML-syntax som stöds av en egenskap beror på vilken typ av objekt egenskapen använder som egenskapstyp. Om egenskapstypen är en primitiv typ, till exempel en dubbel (flyttal eller decimal), heltal, boolesk eller sträng, stöder egenskapen alltid attributsyntax.

Du kan också använda attributsyntax för att ange en egenskap om den objekttyp som du använder för att ange egenskapen kan skapas genom att bearbeta en sträng. För primitiver är detta alltid fallet, typkonverteringen är inbyggd i parsern. Vissa andra objekttyper kan dock också skapas med hjälp av en sträng som anges som ett attributvärde i stället för ett objektelement i ett egenskapselement. För att detta ska fungera måste det finnas en underliggande typkonvertering, som stöds antingen av den specifika egenskapen eller stöds generellt för alla värden som använder den egenskapstypen. Strängvärdet för attributet används för att ange egenskaper som är viktiga för initieringen av det nya objektvärdet. Potentiellt kan en viss typkonverterare också skapa olika underklasser av en gemensam egenskapstyp, beroende på hur den unikt bearbetar information i strängen. Objekttyper som stöder det här beteendet har en särskild grammatik som anges i syntaxavsnittet i referensdokumentationen. Till exempel visar XAML-syntaxen för Pensel hur en attributsyntax kan användas för att skapa ett nytt SolidColorBrush-värde för alla egenskaper av typen Pensel (och det finns många penselegenskaper i Windows Runtime XAML).

XAML-parsning av logik och regler

Ibland är det informativt att läsa XAML på ett liknande sätt som en XAML-parser måste läsa det: som en uppsättning strängtoken som påträffas i linjär ordning. En XAML-parser måste tolka dessa token under en uppsättning regler som ingår i definitionen av hur XAML fungerar.

Att ange ett attributvärde är det typiska sätt på vilket du anger ett egenskapsvärde på ett markeringsspråk, till exempel i XML eller HTML. I följande syntax är objectName det objekt som du vill instansiera, propertyName är namnet på den egenskap som du vill ange för objektet och propertyValue är värdet som ska anges.

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

-or-

<objectName propertyName="propertyValue">

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

</objectName>

Med någon av syntaxerna kan du deklarera ett objekt och ange en egenskap för objektet. Även om det första exemplet är ett enda element i markering, finns det faktiskt diskreta steg här när det gäller hur en XAML-processor parsar den här markeringen.

För det första anger förekomsten av objektelementet att ett nytt objectName-objekt måste instansieras. Endast när en sådan instans finns kan instansegenskapen propertyName anges på den.

En annan regel för XAML är att attribut för ett element måste kunna anges i valfri ordning. Det finns till exempel ingen skillnad mellan <Rectangle Height="50" Width="100" /> och <Rectangle Width="100" Height="50" />. Vilken ordning du använder är en fråga om stil.

Anmärkning

XAML-designers främjar ofta ordningskonventioner vid användning av andra designytor än XML-redigeraren, men du kan redigera XAML fritt senare för att ordna om attributen eller introducera nya attribut.

Anslutna egenskaper

XAML utökar XML genom att lägga till ett syntaxelement som kallas en bifogad egenskap. Precis som syntaxen för egenskapselementet innehåller den kopplade egenskapssyntaxen en punkt och punkten har en särskild betydelse för XAML-parsning. Mer specifikt separerar punkten providern för den anslutna egenskapen och egenskapsnamnet.

I XAML anger du anslutna egenskaper med hjälp av syntaxen AttachedPropertyProvider. PropertyName Här är ett exempel på hur du kan ange den anslutna egenskapen Canvas.Left i XAML:

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

Du kan ange den bifogade egenskapen för element som inte har en egenskap för det namnet i bakgrundstypen, och på så sätt fungerar de ungefär som en global egenskap eller ett attribut som definieras av ett annat XML-namnområde som xml:space-attributet .

I Windows Runtime XAML ser du anslutna egenskaper som stöder dessa scenarier:

Mer information finns i Översikt över bifogade egenskaper.

Literala {-värden

Eftersom den inledande klammerparentessymbolen { är öppningen av markeringstilläggssekvensen använder du en escape-sekvens för att ange ett literalsträngvärde som börjar med {. Escape-sekvensen är "{}". Om du till exempel vill ange ett strängvärde som är en enda inledande klammerparentes anger du attributvärdet som {{}. Du kan också använda de alternativa citattecknen (till exempel ett ' inom ett attributvärde avgränsat med "") för att ange ett {-värde som en sträng.

Anmärkning

"\}" fungerar också om det finns i ett citerat attribut.  

Uppräkningsvärden

Många egenskaper i Windows Runtime API använder uppräkningar som värden. Om medlemmen är en läs- och skrivbar egenskap kan du ställa in en sådan egenskap genom att tillhandahålla ett attributvärde. Du identifierar vilket uppräkningsvärde som ska användas som värdet för egenskapen med hjälp av det okvalificerade namnet på konstantnamnet . Så här ställer du till exempel in UIElement.Visibility i XAML: <Button Visibility="Visible"/>. Här mappas "Visible" som en sträng direkt till en namngiven konstant i synlighetsuppräkningenSynlig.

  • Använd inte ett kvalificerat formulär, det fungerar inte. Detta är till exempel ogiltigt XAML: <Button Visibility="Visibility.Visible"/>.
  • Använd inte värdet för konstanten. Med andra ord ska du inte förlita dig på heltalsvärdet för den uppräkning som finns där explicit eller implicit beroende på hur uppräkningen definierades. Även om det kan verka fungera är det en dålig metod, antingen i XAML eller i kod eftersom du förlitar dig på vad som kan vara en tillfällig implementeringsinformation. Gör till exempel inte så här: <Button Visibility="1"/>.

Anmärkning

I referensavsnitt för API:er som använder XAML och använder uppräkningar klickar du på länken till uppräkningstypen i avsnittet Egenskapsvärdei Syntax. Det här länkar till uppräkningssidan där du kan identifiera de namngivna konstanterna för den uppräkningen.

Uppräkningar kan vara flaggvisa, vilket innebär att de tillägnas FlagsAttribute. Om du behöver ange en kombination av värden för en flaggvis uppräkning som ett XAML-attributvärde använder du namnet på varje uppräkningskonstant, med ett kommatecken (,) mellan varje namn och inga mellanliggande blankstegstecken. Flagwise-attribut är inte vanliga i XAML-ordlistan för Windows Runtime, men ManipulationModes är ett exempel där det finns stöd för att ange ett flaggmässigt uppräkningsvärde i XAML.

Gränssnitt i XAML

I sällsynta fall visas en XAML-syntax där typen av en egenskap är ett gränssnitt. I XAML-typsystemet är en typ som implementerar gränssnittet acceptabel som ett värde när det parsas. Det måste finnas en skapad instans av en sådan typ som kan användas som värde. Du ser ett gränssnitt som används som en typ i XAML-syntaxen för egenskaperna Kommando och KommandoParameter för ButtonBase. Dessa egenskaper stöder MVVM-designmönster (Model-View-ViewModel) där ICommand-gränssnittet är kontraktet för hur vyerna och modellerna interagerar.

XAML-platshållarkonventioner i Windows Runtime-referens

Om du har granskat något av avsnittet Syntax i referensämnen för Windows Runtime-API:er som kan använda XAML har du förmodligen sett att syntaxen innehåller en hel del platshållare. XAML-syntaxen skiljer sig från C#-, Microsoft Visual Basic- eller Visual C++-komponenttilläggssyntaxen (C++/CX) eftersom XAML-syntaxen är en användningssyntax. Det antyder din eventuella användning i dina egna XAML-filer, men utan att vara alltför beskrivande för de värden som du kan använda. Så vanligtvis beskriver användningen en typ av grammatik som blandar literaler och platshållare och definierar några av platshållarna i avsnittet XAML-värden .

När du ser typnamn/elementnamn i en XAML-syntax för en egenskap är namnet som visas för den typ som ursprungligen definierar egenskapen. Men Windows Runtime XAML stöder en klassarvmodell för de DependencyObject-baserade klasserna. Så du kan ofta använda ett attribut i en klass som inte bokstavligen är den definierande klassen, utan i stället härleds från en klass som först definierade egenskapen/attributet. Du kan till exempel ange Synlighet som ett attribut för valfri UIElement-härledd klass med hjälp av ett djupt arv. Till exempel: <Button Visibility="Visible" />. Ta därför inte elementnamnet som visas i någon XAML-användningssyntax för bokstavligt; syntaxen kan vara användbar för element som representerar den klassen och även element som representerar en härledd klass. I fall där det är sällsynt eller omöjligt för typen som visas som det definierande elementet att vara i en verklig användning, avsiktligt är typnamnet skrivet med små bokstäver i syntaxen. Syntaxen som visas för UIElement.Visibility är till exempel :

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

Många XAML-syntaxavsnitt innehåller platshållare i avsnittet "Användning" som sedan definieras i ett XAML-värden som är direkt under avsnittet Syntax .

XAML-användningsavsnitt använder också olika generaliserade platshållare. Dessa platshållare omdefinieras inte varje gång i XAML-värden, eftersom du gissar eller så småningom lär dig vad de representerar. Vi tror att de flesta läsare skulle tröttna på att se dem i XAML-värden om och om igen så att vi utelämnade dem från definitionerna. Som referens finns här en lista över några av dessa platshållare och vad de betyder i allmän mening:

  • objekt: teoretiskt sett alla objektvärden, men ofta praktiskt taget begränsade till vissa typer av objekt, till exempel ett val av sträng eller objekt, och du bör kontrollera anmärkningarna på referenssidan för mer information.
  • objektegenskap: objektegenskap i kombination används för fall där syntaxen som visas är syntaxen för en typ som kan användas som ett attributvärde för många egenskaper. Till exempel innehåller Xaml-attributanvändningen som visas för Pensel : <objectproperty="predefinedColorName"/>
  • eventhandler: Detta visas som attributvärdet för varje XAML-syntax som visas för ett händelseattribut. Det du anger här är funktionsnamnet för en händelsehanterarfunktion. Den funktionen måste definieras i koden bakom för XAML-sidan. På programmeringsnivå måste den funktionen matcha ombudssignaturen för händelsen som du hanterar, annars kompileras inte appkoden. Men det är verkligen en programmeringsövervägande, inte ett XAML-övervägande, så vi försöker inte antyda något om delegattypen i XAML-syntaxen. Om du vill veta vilket ombud du ska implementera för en händelse finns det i avsnittet Händelseinformation i referensavsnittet för händelsen på en tabellrad med etiketten Ombud.
  • enumMemberName: visas i attributsyntax för alla uppräkningar. Det finns en liknande platshållare för egenskaper som använder ett uppräkningsvärde, men det prefixar vanligtvis platshållaren med en antydan om uppräkningens namn. Syntaxen som visas för FrameworkElement.FlowDirection är < till exempel frameworkElementFlowDirection="flowDirectionMemberName"/>. Om du är på en av dessa egenskapsreferenssidor klickar du på länken till uppräkningstypen som visas i avsnittet Egenskapsvärde bredvid texten Typ:. För attributvärdet för en egenskap som använder den uppräkningen kan du använda valfri sträng som visas i kolumnen Medlem i listan Medlemmar .
  • double, int, string, bool: Dessa är primitiva typer som är kända för XAML-språket. Om du programmerar med C# eller Visual Basic projiceras dessa typer till Microsoft .NET-motsvarande typer som Double, Int32, String och Boolean, och du kan använda alla medlemmar på dessa .NET-typer när du arbetar med dina XAML-definierade värden i .NET code-behind. Om du programmerar med C++/CX använder du de primitiva C++-typerna, men du kan också överväga dessa motsvarande typer som definierats av plattformsnamnområdet , till exempel Plattform::Sträng. Ibland finns det ytterligare värdebegränsningar för vissa egenskaper. Men du ser vanligtvis dessa i avsnittet Egenskapsvärde eller Kommentarer och inte i ett XAML-avsnitt, eftersom sådana begränsningar gäller både för kodanvändning och XAML-användning.

Tips och tricks, anteckningar om stil

  • Markeringstillägg beskrivs i allmänhet i den huvudsakliga XAML-översikten. Men den markeringsutvidgning som mest påverkar vägledningen som ges i det här avsnittet är StaticResource (och relaterade ThemeResource). Funktionen för StaticResource-markeringstillägget är att möjliggöra uppdelning av XAML till återanvändbara resurser från en XAML ResourceDictionary. Du definierar nästan alltid kontrollmallar och relaterade formatmallar i en ResourceDictionary. Du definierar ofta de mindre delarna i en kontrollmallsdefinition eller appspecifik stil även i en ResourceDictionary , till exempel en SolidColorBrush för en färg som appen använder mer än en gång för olika delar av användargränssnittet. Med hjälp av en StaticResource kan alla egenskaper som annars skulle kräva att en egenskapselementanvändning anges nu anges i attributsyntaxen. Men fördelarna med att faktorisera XAML för återanvändning går utöver att bara förenkla syntaxen på sidnivå. Mer information finns i Resursdictionary- och XAML-resursreferenser.
  • Du ser flera olika konventioner för hur blanksteg och radmatningar tillämpas i XAML-exempel. I synnerhet finns det olika konventioner för hur du delar upp objektelement som har många olika attribut inställda. Det är bara en fråga om stil. Visual Studio XML-redigeraren tillämpar vissa standardformatregler när du redigerar XAML, men du kan ändra dessa i inställningarna. Det finns ett litet antal fall där det tomma utrymmet i en XAML-fil anses vara betydande. Mer information finns i XAML och blanksteg.
  • Last updated on