Parte 2.Part 2. Sintassi XAML essenzialeEssential XAML Syntax

Scaricare l'esempio. Scaricare l'esempioDownload Sample. Download the sample

XAML è progettato principalmente per la creazione di istanze e l'inizializzazione di oggetti. Spesso, tuttavia, le proprietà devono essere impostate su oggetti complessi che non possono essere facilmente rappresentati come stringhe XML e talvolta le proprietà definite da una classe devono essere impostate su una classe figlio. Queste due esigenze richiedono le funzionalità di sintassi XAML essenziali degli elementi proprietà e delle proprietà associate.XAML is mostly designed for instantiating and initializing objects. But often, properties must be set to complex objects that cannot easily be represented as XML strings, and sometimes properties defined by one class must be set on a child class. These two needs require the essential XAML syntax features of property elements and attached properties.

Elementi di proprietàProperty Elements

In XAML le proprietà delle classi vengono in genere impostate come attributi XML:In XAML, properties of classes are normally set as XML attributes:

<Label Text="Hello, XAML!"
       VerticalOptions="Center"
       FontAttributes="Bold"
       FontSize="Large"
       TextColor="Aqua" />

Esiste tuttavia un modo alternativo per impostare una proprietà in XAML.However, there is an alternative way to set a property in XAML. Per provare questa alternativa con TextColor , eliminare innanzitutto l'impostazione TextColor esistente:To try this alternative with TextColor, first delete the existing TextColor setting:

<Label Text="Hello, XAML!"
       VerticalOptions="Center"
       FontAttributes="Bold"
       FontSize="Large" />

Aprire il tag di elemento Label vuoto separarlo in tag di inizio e di fine:Open up the empty-element Label tag by separating it into start and end tags:

<Label Text="Hello, XAML!"
       VerticalOptions="Center"
       FontAttributes="Bold"
       FontSize="Large">

</Label>

All'interno di questi tag aggiungere tag di inizio e di fine costituiti dal nome della classe e da un nome di proprietà separati da un punto:Within these tags, add start and end tags that consist of the class name and a property name separated by a period:

<Label Text="Hello, XAML!"
       VerticalOptions="Center"
       FontAttributes="Bold"
       FontSize="Large">
    <Label.TextColor>

    </Label.TextColor>
</Label>

Impostare il valore della proprietà come contenuto di questi nuovi tag, nel modo seguente:Set the property value as content of these new tags, like this:

<Label Text="Hello, XAML!"
       VerticalOptions="Center"
       FontAttributes="Bold"
       FontSize="Large">
    <Label.TextColor>
        Aqua
    </Label.TextColor>
</Label>

Questi due modi per specificare la proprietà sono funzionalmente equivalenti, ma non usano i due modi per la stessa proprietà perché in questo modo la proprietà verrebbe impostata due volte e potrebbe essere TextColor ambigua.These two ways to specify the TextColor property are functionally equivalent, but don't use the two ways for the same property because that would effectively be setting the property twice, and might be ambiguous.

Con questa nuova sintassi è possibile introdurre una terminologia utile:With this new syntax, some handy terminology can be introduced:

  • Label è un elemento oggetto.Label is an object element. Si tratta di Xamarin.Forms un oggetto espresso come elemento XML.It is a Xamarin.Forms object expressed as an XML element.
  • Text, VerticalOptions e sono attributi di FontAttributes FontSize proprietà.Text, VerticalOptions, FontAttributes and FontSize are property attributes. Si tratta Xamarin.Forms di proprietà espresse come attributi XML.They are Xamarin.Forms properties expressed as XML attributes.
  • Nel frammento finale, TextColor è diventato un elemento proprietà.In that final snippet, TextColor has become a property element. Si tratta di Xamarin.Forms una proprietà, ma ora è un elemento XML.It is a Xamarin.Forms property but it is now an XML element.

La definizione degli elementi di proprietà potrebbe all'inizio sembrare una violazione della sintassi XML, ma non lo è.The definition of property elements might at first seem to be a violation of XML syntax, but it’s not. Il punto non ha un significato speciale in XML.The period has no special meaning in XML. Per un decodificatore XML, Label.TextColor è semplicemente un elemento figlio normale.To an XML decoder, Label.TextColor is simply a normal child element.

In XAML, tuttavia, questa sintassi è molto speciale.In XAML, however, this syntax is very special. Una delle regole per gli elementi proprietà è che non può essere visualizzato altro nel Label.TextColor tag.One of the rules for property elements is that nothing else can appear in the Label.TextColor tag. Il valore della proprietà è sempre definito come contenuto tra i tag di inizio e di fine dell'elemento proprietà.The value of the property is always defined as content between the property-element start and end tags.

È possibile usare la sintassi degli elementi proprietà in più di una proprietà:You can use property-element syntax on more than one property:

<Label Text="Hello, XAML!"
       VerticalOptions="Center">
    <Label.FontAttributes>
        Bold
    </Label.FontAttributes>
    <Label.FontSize>
        Large
    </Label.FontSize>
    <Label.TextColor>
        Aqua
    </Label.TextColor>
</Label>

Oppure è possibile usare la sintassi degli elementi proprietà per tutte le proprietà:Or you can use property-element syntax for all the properties:

<Label>
    <Label.Text>
        Hello, XAML!
    </Label.Text>
    <Label.FontAttributes>
        Bold
    </Label.FontAttributes>
    <Label.FontSize>
        Large
    </Label.FontSize>
    <Label.TextColor>
        Aqua
    </Label.TextColor>
    <Label.VerticalOptions>
        Center
    </Label.VerticalOptions>
</Label>

In un primo momento, la sintassi degli elementi proprietà potrebbe sembrare una sostituzione superflua a lungo termine di un elemento relativamente semplice e in questi esempi è sicuramente il caso.At first, property-element syntax might seem like an unnecessary long-winded replacement for something comparatively quite simple, and in these examples that is certainly the case.

Tuttavia, la sintassi degli elementi proprietà diventa essenziale quando il valore di una proprietà è troppo complesso per essere espresso come stringa semplice.However, property-element syntax becomes essential when the value of a property is too complex to be expressed as a simple string. All'interno dei tag property-element è possibile creare un'istanza di un altro oggetto e impostarne le proprietà.Within the property-element tags you can instantiate another object and set its properties. Ad esempio, è possibile impostare in modo esplicito una proprietà come VerticalOptions su un valore con le impostazioni della LayoutOptions proprietà:For example, you can explicitly set a property such as VerticalOptions to a LayoutOptions value with property settings:

<Label>
    ...
    <Label.VerticalOptions>
        <LayoutOptions Alignment="Center" />
    </Label.VerticalOptions>
</Label>

Un altro esempio: Grid ha due proprietà denominate e RowDefinitions ColumnDefinitions .Another example: The Grid has two properties named RowDefinitions and ColumnDefinitions. Queste due proprietà sono di RowDefinitionCollection tipo e , che sono raccolte di oggetti e ColumnDefinitionCollection RowDefinition ColumnDefinition .These two properties are of type RowDefinitionCollection and ColumnDefinitionCollection, which are collections of RowDefinition and ColumnDefinition objects. È necessario usare la sintassi degli elementi proprietà per impostare queste raccolte.You need to use property element syntax to set these collections.

Ecco l'inizio del file XAML per una classe, che mostra i tag GridDemoPage degli elementi proprietà per le raccolte e RowDefinitions ColumnDefinitions :Here’s the beginning of the XAML file for a GridDemoPage class, showing the property element tags for the RowDefinitions and ColumnDefinitions collections:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="XamlSamples.GridDemoPage"
             Title="Grid Demo Page">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="*" />
            <RowDefinition Height="100" />
        </Grid.RowDefinitions>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="Auto" />
            <ColumnDefinition Width="*" />
            <ColumnDefinition Width="100" />
        </Grid.ColumnDefinitions>
        ...
    </Grid>
</ContentPage>

Si noti la sintassi abbreviata per definire le celle ridimensionate automaticamente, le celle con larghezze e altezze in pixel e le impostazioni delle stelle.Notice the abbreviated syntax for defining auto-sized cells, cells of pixel widths and heights, and star settings.

Proprietà associateAttached Properties

Si è appena visto che richiede elementi della proprietà per le raccolte e Grid per definire le righe e le RowDefinitions ColumnDefinitions colonne.You've just seen that the Grid requires property elements for the RowDefinitions and ColumnDefinitions collections to define the rows and columns. Tuttavia, deve essere disponibile anche un modo per il programmatore di indicare la riga e la colonna in cui risiede ogni elemento Grid figlio di .However, there must also be some way for the programmer to indicate the row and column where each child of the Grid resides.

All'interno del tag per ogni elemento Grid figlio di è possibile specificare la riga e la colonna dell'elemento figlio usando gli attributi seguenti:Within the tag for each child of the Grid you specify the row and column of that child using the following attributes:

  • Grid.Row
  • Grid.Column

I valori predefiniti di questi attributi sono 0.The default values of these attributes are 0. È anche possibile indicare se un elemento figlio si estende su più righe o colonne con questi attributi:You can also indicate if a child spans more than one row or column with these attributes:

  • Grid.RowSpan
  • Grid.ColumnSpan

Questi due attributi hanno valori predefiniti di 1.These two attributes have default values of 1.

Ecco il file GridDemoPage.xaml completo:Here’s the complete GridDemoPage.xaml file:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="XamlSamples.GridDemoPage"
             Title="Grid Demo Page">

    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="*" />
            <RowDefinition Height="100" />
        </Grid.RowDefinitions>

        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="Auto" />
            <ColumnDefinition Width="*" />
            <ColumnDefinition Width="100" />
        </Grid.ColumnDefinitions>

        <Label Text="Autosized cell"
               Grid.Row="0" Grid.Column="0"
               TextColor="White"
               BackgroundColor="Blue" />

        <BoxView Color="Silver"
                 HeightRequest="0"
                 Grid.Row="0" Grid.Column="1" />

        <BoxView Color="Teal"
                 Grid.Row="1" Grid.Column="0" />

        <Label Text="Leftover space"
               Grid.Row="1" Grid.Column="1"
               TextColor="Purple"
               BackgroundColor="Aqua"
               HorizontalTextAlignment="Center"
               VerticalTextAlignment="Center" />

        <Label Text="Span two rows (or more if you want)"
               Grid.Row="0" Grid.Column="2" Grid.RowSpan="2"
               TextColor="Yellow"
               BackgroundColor="Blue"
               HorizontalTextAlignment="Center"
               VerticalTextAlignment="Center" />

        <Label Text="Span two columns"
               Grid.Row="2" Grid.Column="0" Grid.ColumnSpan="2"
               TextColor="Blue"
               BackgroundColor="Yellow"
               HorizontalTextAlignment="Center"
               VerticalTextAlignment="Center" />

        <Label Text="Fixed 100x100"
               Grid.Row="2" Grid.Column="2"
               TextColor="Aqua"
               BackgroundColor="Red"
               HorizontalTextAlignment="Center"
               VerticalTextAlignment="Center" />

    </Grid>
</ContentPage>

Le Grid.Row impostazioni e di Grid.Column 0 non sono necessarie, ma sono generalmente incluse per maggiore chiarezza.The Grid.Row and Grid.Column settings of 0 are not required but are generally included for purposes of clarity.

L'aspetto è il seguente:Here’s what it looks like:

Layout griglia.Grid Layout.

A partire esclusivamente dalla sintassi , questi attributi , , e sembrano essere campi statici o proprietà di , ma è interessante notare che non definisce nulla denominato Grid.Row Grid.Column , , o Grid.RowSpan Grid.ColumnSpan Grid Grid Row Column RowSpan ColumnSpan .Judging solely from the syntax, these Grid.Row, Grid.Column, Grid.RowSpan, and Grid.ColumnSpan attributes appear to be static fields or properties of Grid, but interestingly enough, Grid does not define anything named Row, Column, RowSpan, or ColumnSpan.

Definisce Grid invece quattro proprietà associabili denominate RowProperty , , e ColumnProperty RowSpanProperty ColumnSpanProperty .Instead, Grid defines four bindable properties named RowProperty, ColumnProperty, RowSpanProperty, and ColumnSpanProperty. Si tratta di tipi speciali di proprietà associabili note come proprietà associate.These are special types of bindable properties known as attached properties. Sono definiti dalla classe Grid , ma impostati sugli elementi figlio di Grid .They are defined by the Grid class but set on children of the Grid.

Quando si vogliono usare queste proprietà associate nel codice, la classe Grid fornisce metodi statici denominati SetRow , e così GetColumn via.When you wish to use these attached properties in code, the Grid class provides static methods named SetRow, GetColumn, and so forth. In XAML, tuttavia, queste proprietà associate vengono impostate come attributi negli elementi figlio di Grid usando nomi di proprietà semplici.But in XAML, these attached properties are set as attributes in the children of the Grid using simple properties names.

Le proprietà associate sono sempre riconoscibili nei file XAML come attributi contenenti sia una classe che un nome di proprietà separati da un punto.Attached properties are always recognizable in XAML files as attributes containing both a class and a property name separated by a period. Vengono chiamate proprietà associate perché sono definite da una classe (in questo caso , ) ma associate ad altri oggetti (in questo caso, elementi figlio Grid di Grid ).They are called attached properties because they are defined by one class (in this case, Grid) but attached to other objects (in this case, children of the Grid). Durante il layout, può interrogare i valori di queste proprietà associate per Grid sapere dove posizionare ogni figlio.During layout, the Grid can interrogate the values of these attached properties to know where to place each child.

La AbsoluteLayout classe definisce due proprietà associate denominate e LayoutBounds LayoutFlags .The AbsoluteLayout class defines two attached properties named LayoutBounds and LayoutFlags. Ecco un modello a scacchi realizzato usando le caratteristiche proporzionali di posizionamento e ridimensionamento di AbsoluteLayout :Here’s a checkerboard pattern realized using the proportional positioning and sizing features of AbsoluteLayout:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="XamlSamples.AbsoluteDemoPage"
             Title="Absolute Demo Page">

    <AbsoluteLayout BackgroundColor="#FF8080">
        <BoxView Color="#8080FF"
                 AbsoluteLayout.LayoutBounds="0.33, 0, 0.25, 0.25"
                 AbsoluteLayout.LayoutFlags="All" />

        <BoxView Color="#8080FF"
                 AbsoluteLayout.LayoutBounds="1, 0, 0.25, 0.25"
                 AbsoluteLayout.LayoutFlags="All" />

        <BoxView Color="#8080FF"
                 AbsoluteLayout.LayoutBounds="0, 0.33, 0.25, 0.25"
                 AbsoluteLayout.LayoutFlags="All" />

        <BoxView Color="#8080FF"
                 AbsoluteLayout.LayoutBounds="0.67, 0.33, 0.25, 0.25"
                 AbsoluteLayout.LayoutFlags="All" />

        <BoxView Color="#8080FF"
                 AbsoluteLayout.LayoutBounds="0.33, 0.67, 0.25, 0.25"
                 AbsoluteLayout.LayoutFlags="All" />

        <BoxView Color="#8080FF"
                 AbsoluteLayout.LayoutBounds="1, 0.67, 0.25, 0.25"
                 AbsoluteLayout.LayoutFlags="All" />

        <BoxView Color="#8080FF"
                 AbsoluteLayout.LayoutBounds="0, 1, 0.25, 0.25"
                 AbsoluteLayout.LayoutFlags="All" />

        <BoxView Color="#8080FF"
                 AbsoluteLayout.LayoutBounds="0.67, 1, 0.25, 0.25"
                 AbsoluteLayout.LayoutFlags="All" />

  </AbsoluteLayout>
</ContentPage>

Ed ecco:And here it is:

Layout assoluto.Absolute Layout.

<span data-ttu-id="6aa11-164">Per qualcosa di simile, è possibile mettere in discussione la sapienza di usare XAML.For something like this, you might question the wisdom of using XAML. Certamente, la ripetizione e la regolarità del rettangolo suggeriscono che LayoutBounds potrebbe essere realizzato meglio nel codice.Certainly, the repetition and regularity of the LayoutBounds rectangle suggests that it might be better realized in code.

Si tratta sicuramente di un problema legittimo e non c'è alcun problema nel bilanciare l'uso di codice e markup durante la definizione delle interfacce utente.That’s certainly a legitimate concern, and there’s no problem with balancing the use of code and markup when defining your user interfaces. È facile definire alcuni oggetti visivi in XAML e quindi usare il costruttore del file code-behind per aggiungere altri oggetti visivi che potrebbero essere generati meglio nei cicli.It’s easy to define some of the visuals in XAML and then use the constructor of the code-behind file to add some more visuals that might be better generated in loops.

Proprietà di contenutoContent Properties

Negli esempi precedenti gli oggetti , e sono impostati sulla proprietà di e gli elementi figlio di questi layout sono StackLayout effettivamente elementi nella raccolta Grid AbsoluteLayout Content ContentPage Children .In the previous examples, the StackLayout, Grid, and AbsoluteLayout objects are set to the Content property of the ContentPage, and the children of these layouts are actually items in the Children collection. Queste proprietà Content e sono tuttavia presenti nel file Children XAML.Yet these Content and Children properties are nowhere in the XAML file.

È certamente possibile includere le Content proprietà e come elementi Children proprietà, ad esempio nell'esempio XamlPlusCode:You can certainly include the Content and Children properties as property elements, such as in the XamlPlusCode sample:

<ContentPage xmlns=&quot;http://xamarin.com/schemas/2014/forms&quot;
             xmlns:x=&quot;http://schemas.microsoft.com/winfx/2009/xaml&quot;
             x:Class=&quot;XamlSamples.XamlPlusCodePage&quot;
             Title=&quot;XAML + Code Page&quot;>
    <ContentPage.Content>
        <StackLayout>
            <StackLayout.Children>
                <Slider VerticalOptions=&quot;CenterAndExpand&quot;
                        ValueChanged=&quot;OnSliderValueChanged&quot; />

                <Label x:Name=&quot;valueLabel&quot;
                       Text=&quot;A simple Label&quot;
                       FontSize=&quot;Large&quot;
                       HorizontalOptions=&quot;Center&quot;
                       VerticalOptions=&quot;CenterAndExpand&quot; />

                <Button Text=&quot;Click Me!&quot;
                      HorizontalOptions=&quot;Center&quot;
                      VerticalOptions=&quot;CenterAndExpand&quot;
                      Clicked=&quot;OnButtonClicked&quot; />
            </StackLayout.Children>
        </StackLayout>
    </ContentPage.Content>
</ContentPage>

La domanda reale è: Perché questi elementi di proprietà non sono necessari nel file XAML?The real question is: Why are these property elements not required in the XAML file?

Gli elementi definiti in per l'uso in XAML possono avere una proprietà Xamarin.Forms contrassegnata ContentProperty nell'attributo nella classe .Elements defined in Xamarin.Forms for use in XAML are allowed to have one property flagged in the ContentProperty attribute on the class. Se si cerca la ContentPage classe nella documentazione Xamarin.Forms online, verrà visualizzato questo attributo:If you look up the ContentPage class in the online Xamarin.Forms documentation, you’ll see this attribute:

[Xamarin.Forms.ContentProperty(&quot;Content")]
public class ContentPage : TemplatedPage

Ciò significa che i Content tag property-element non sono obbligatori.This means that the Content property-element tags are not required. Si presuppone che qualsiasi contenuto XML visualizzato tra i tag di inizio e di fine ContentPage venga assegnato alla proprietà Content .Any XML content that appears between the start and end ContentPage tags is assumed to be assigned to the Content property.

StackLayout, , e derivano tutti da e, se si Grid AbsoluteLayout cerca nella RelativeLayout Layout<View> Layout<T> Xamarin.Forms documentazione, verrà visualizzato un altro ContentProperty attributo:StackLayout, Grid, AbsoluteLayout, and RelativeLayout all derive from Layout<View>, and if you look up Layout<T> in the Xamarin.Forms documentation, you’ll see another ContentProperty attribute:

[Xamarin.Forms.ContentProperty("Children")]
public abstract class Layout<T> : Layout ...

In questo modo il contenuto del layout può essere aggiunto automaticamente alla Children raccolta senza tag Children espliciti degli elementi proprietà.That allows content of the layout to be automatically added to the Children collection without explicit Children property-element tags.

Anche altre classi dispongono di ContentProperty definizioni di attributi.Other classes also have ContentProperty attribute definitions. Ad esempio, la proprietà content di Label è Text .For example, the content property of Label is Text. Per altre informazioni, vedere la documentazione dell'API.Check the API documentation for others.

Differenze di piattaforma con OnPlatformPlatform Differences with OnPlatform

Nelle applicazioni a pagina singola è comune impostare la proprietà nella pagina per evitare di Padding sovrascrivere la barra di stato di iOS.In single page applications, it is common to set the Padding property on the page to avoid overwriting the iOS status bar. Nel codice è possibile usare la Device.RuntimePlatform proprietà a questo scopo:In code, you can use the Device.RuntimePlatform property for this purpose:

if (Device.RuntimePlatform == Device.iOS)
{
    Padding = new Thickness(0, 20, 0, 0);
}

È anche possibile eseguire un'operazione simile in XAML usando le OnPlatform classi On e .You can also do something similar in XAML using the OnPlatform and On classes. Includere innanzitutto gli elementi della proprietà Padding per la proprietà nella parte superiore della pagina:First include property elements for the Padding property near the top of the page:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="...">

    <ContentPage.Padding>

    </ContentPage.Padding>
    ...
</ContentPage>

All'interno di questi tag includere un OnPlatform tag .Within these tags, include an OnPlatform tag. OnPlatform è una classe generica.OnPlatform is a generic class. È necessario specificare l'argomento di tipo generico, in questo caso Thickness , che è il tipo di Padding proprietà.You need to specify the generic type argument, in this case, Thickness, which is the type of Padding property. Fortunatamente, è presente un attributo XAML specifico per definire argomenti generici denominati x:TypeArguments .Fortunately, there’s a XAML attribute specifically to define generic arguments called x:TypeArguments. Deve corrispondere al tipo della proprietà che si sta impostando:This should match the type of the property you're setting:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="...">

    <ContentPage.Padding>
        <OnPlatform x:TypeArguments="Thickness">

        </OnPlatform>
    </ContentPage.Padding>
  ...
</ContentPage>

OnPlatform dispone di una proprietà Platforms denominata che è un di oggetti IList On .OnPlatform has a property named Platforms that is an IList of On objects. Usare i tag degli elementi proprietà per tale proprietà:Use property element tags for that property:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="...">

    <ContentPage.Padding>
        <OnPlatform x:TypeArguments="Thickness">
            <OnPlatform.Platforms>

            </OnPlatform.Platforms>
        </OnPlatform>
    </ContentPage.Padding>
  ...
</ContentPage>

Aggiungere ora On gli elementi .Now add On elements. Per ognuno di essi impostare Platform la proprietà e la proprietà sul markup per la proprietà Value Thickness :For each one set the Platform property and the Value property to markup for the Thickness property:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="...">

    <ContentPage.Padding>
        <OnPlatform x:TypeArguments="Thickness">
            <OnPlatform.Platforms>
                <On Platform="iOS" Value="0, 20, 0, 0" />
                <On Platform="Android" Value="0, 0, 0, 0" />
                <On Platform="UWP" Value="0, 0, 0, 0" />
            </OnPlatform.Platforms>
        </OnPlatform>
    </ContentPage.Padding>
  ...
</ContentPage>

Questo markup può essere semplificato.This markup can be simplified. La proprietà content di OnPlatform è , quindi i tag degli elementi proprietà possono essere Platforms rimossi:The content property of OnPlatform is Platforms, so those property-element tags can be removed:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="...">

    <ContentPage.Padding>
        <OnPlatform x:TypeArguments="Thickness">
            <On Platform="iOS" Value="0, 20, 0, 0" />
            <On Platform="Android" Value="0, 0, 0, 0" />
            <On Platform="UWP" Value="0, 0, 0, 0" />
        </OnPlatform>
    </ContentPage.Padding>
  ...
</ContentPage>

La Platform proprietà di è di tipo , pertanto è possibile includere più piattaforme se i valori sono gli On IList<string> stessi:The Platform property of On is of type IList<string>, so you can include multiple platforms if the values are the same:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="...">

    <ContentPage.Padding>
        <OnPlatform x:TypeArguments="Thickness">
            <On Platform="iOS" Value="0, 20, 0, 0" />
            <On Platform="Android, UWP" Value="0, 0, 0, 0" />
        </OnPlatform>
    </ContentPage.Padding>
  ...
</ContentPage>

Poiché Android e UWP sono impostati sul valore predefinito Padding di , tale tag può essere rimosso:Because Android and UWP are set to the default value of Padding, that tag can be removed:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="...">

    <ContentPage.Padding>
        <OnPlatform x:TypeArguments="Thickness">
            <On Platform="iOS" Value="0, 20, 0, 0" />
        </OnPlatform>
    </ContentPage.Padding>
  ...
</ContentPage>

Questo è il modo standard per impostare una proprietà dipendente dalla Padding piattaforma in XAML.This is the standard way to set a platform-dependent Padding property in XAML. Se Value l'impostazione non può essere rappresentata da una singola stringa, è possibile definirne gli elementi di proprietà:If the Value setting cannot be represented by a single string, you can define property elements for it:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="...">

    <ContentPage.Padding>
        <OnPlatform x:TypeArguments="Thickness">
            <On Platform="iOS">
                <On.Value>
                    0, 20, 0, 0
                </On.Value>
            </On>
        </OnPlatform>
    </ContentPage.Padding>
  ...
</ContentPage>

Nota

OnPlatformL'estensione di markup può essere usata anche in XAML per personalizzare l'aspetto dell'interfaccia utente in base alla piattaforma.The OnPlatform markup extension can also be used in XAML to customize UI appearance on a per-platform basis. Fornisce le stesse funzionalità delle classi e , ma con una OnPlatform On rappresentazione più concisa.It provides the same functionality as the OnPlatform and On classes, but with a more concise representation. Per altre informazioni, vedere Estensione di markup OnPlatform.For more information, see OnPlatform Markup Extension.

RiepilogoSummary

Con gli elementi proprietà e le proprietà associate, è stata stabilita gran parte della sintassi XAML di base.With property elements and attached properties, much of the basic XAML syntax has been established. Tuttavia, a volte è necessario impostare le proprietà sugli oggetti in modo indiretto, ad esempio da un dizionario risorse.However, sometimes you need to set properties to objects in an indirect manner, for example, from a resource dictionary. Questo approccio è trattato nella parte successiva, parte 3. Estensioni di markup XAML.This approach is covered in the next part, Part 3. XAML Markup Extensions.