Consumo de extensões de marcação XAML

As extensões de marcação XAML ajudam a aprimorar o poder e a flexibilidade do XAML, permitindo que os atributos de elemento sejam definidos de várias fontes. Várias extensões de marcação XAML fazem parte da especificação XAML 2009. Eles aparecem em arquivos XAML com o prefixo de x namespace habitual e são comumente referidos com esse prefixo. Este artigo descreve as seguintes extensões de marcação:

• x:Static – referenciar propriedades estáticas, campos ou membros de enumeração.
• x:Reference – referenciar elementos nomeados na página.
• x:Type – definir um atributo para um System.Type objeto.
• x:Array – construir uma matriz de objetos de um tipo particular.
• x:Null – definir um atributo para um null valor.
• OnPlatform – personalizar a aparência da interface do usuário em uma base por plataforma.
• OnIdiom – personalizar a aparência da interface do usuário com base no idioma do dispositivo em que o aplicativo está sendo executado.
• DataTemplate – converte um tipo em um DataTemplatearquivo .
• FontImage – exibir um ícone de fonte em qualquer visualização que possa exibir um ImageSourcearquivo .
• AppThemeBinding – consumir um recurso baseado no tema atual do sistema.

Extensões de marcação XAML adicionais têm sido historicamente suportadas por outras implementações XAML e também são suportadas pelo Xamarin.Forms. Estes são descritos mais detalhadamente em outros artigos:

• StaticResource - objetos de referência de um dicionário de recursos, conforme descrito no artigo Dicionários de Recursos.
• DynamicResource- responder a alterações em objetos em um dicionário de recursos, conforme descrito no artigo Estilos dinâmicos.
• Binding - estabelecer um link entre as propriedades de dois objetos, conforme descrito no artigo Vinculação de dados.
• TemplateBinding- Executa a vinculação de dados a partir de um modelo de controle, conforme discutido nos modelos de controle do artigoXamarin.Forms.
• RelativeSource - define a fonte vinculante em relação à posição do alvo vinculante, conforme discutido no artigo Vinculações relativas.

O RelativeLayout layout faz uso da extensão ConstraintExpressionde marcação personalizada . Essa extensão de marcação é descrita no artigo RelativeLayout.

x:Extensão de marcação estática

A x:Static extensão de marcação é suportada StaticExtension pela classe. A classe tem uma única propriedade chamada Member do tipo string que você define como o nome de uma constante pública, propriedade estática, campo estático ou membro de enumeração.

Uma maneira comum de usar x:Static é primeiro definir uma classe com algumas constantes ou variáveis estáticas, como esta pequena AppConstants classe:

static class AppConstants
{
    public static double NormalFontSize = 18;
}

A página x:Static Demo demonstra várias maneiras de usar a x:Static extensão de marcação. A abordagem mais detalhada instancia a StaticExtension classe entre Label.FontSize as tags property-element:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:sys="clr-namespace:System;assembly=netstandard"
             xmlns:local="clr-namespace:MarkupExtensions"
             x:Class="MarkupExtensions.StaticDemoPage"
             Title="x:Static Demo">
    <StackLayout Margin="10, 0">
        <Label Text="Label No. 1">
            <Label.FontSize>
                <x:StaticExtension Member="local:AppConstants.NormalFontSize" />
            </Label.FontSize>
        </Label>

        ···

    </StackLayout>
</ContentPage>

O analisador XAML também permite que a StaticExtension classe seja abreviada como x:Static:

<Label Text="Label No. 2">
    <Label.FontSize>
        <x:Static Member="local:AppConstants.NormalFontSize" />
    </Label.FontSize>
</Label>

Isso pode ser simplificado ainda mais, mas a mudança introduz uma nova sintaxe: consiste em colocar a classe e a StaticExtension configuração do membro em chaves curvas. A expressão resultante é definida diretamente para o atributo FontSize :

<Label Text="Label No. 3"
       FontSize="{x:StaticExtension Member=local:AppConstants.NormalFontSize}" />

Observe que não há aspas dentro das chaves encaracoladas. A Member propriedade de StaticExtension não é mais um atributo XML. Em vez disso, faz parte da expressão para a extensão de marcação.

Assim como você pode abreviar x:StaticExtension para x:Static quando você usá-lo como um elemento de objeto, você também pode abreviar na expressão dentro de chaves:

<Label Text="Label No. 4"
       FontSize="{x:Static Member=local:AppConstants.NormalFontSize}" />

A StaticExtension classe tem um ContentProperty atributo que faz referência à propriedade Member, que marca essa propriedade como a propriedade de conteúdo padrão da classe. Para extensões de marcação XAML expressas com chaves, você pode eliminar a Member= parte da expressão:

<Label Text="Label No. 5"
       FontSize="{x:Static local:AppConstants.NormalFontSize}" />

Esta é a forma mais comum da extensão de x:Static marcação.

A página Demonstração estática contém dois outros exemplos. A marca raiz do arquivo XAML contém uma declaração de namespace XML para o namespace .NET System :

xmlns:sys="clr-namespace:System;assembly=netstandard"

Isso permite que o tamanho da Label fonte seja definido para o campo Math.PIestático . Isso resulta em um texto bastante pequeno, portanto, a Scale propriedade é definida como Math.E:

<Label Text="&#x03C0; &#x00D7; E sized text"
       FontSize="{x:Static sys:Math.PI}"
       Scale="{x:Static sys:Math.E}"
       HorizontalOptions="Center" />

O exemplo final exibe o Device.RuntimePlatform valor. A Environment.NewLine propriedade static é usada para inserir um caractere de nova linha entre os dois Span objetos:

<Label HorizontalTextAlignment="Center"
       FontSize="{x:Static local:AppConstants.NormalFontSize}">
    <Label.FormattedText>
        <FormattedString>
            <Span Text="Runtime Platform: " />
            <Span Text="{x:Static sys:Environment.NewLine}" />
            <Span Text="{x:Static Device.RuntimePlatform}" />
        </FormattedString>
    </Label.FormattedText>
</Label>

Aqui está o exemplo em execução:

x:Extensão de marcação de referência

A x:Reference extensão de marcação é suportada ReferenceExtension pela classe. A classe tem uma única propriedade chamada Name do tipo string que você definiu como o nome de um elemento na página que recebeu um nome com x:Name. Essa Name propriedade é a propriedade content do ReferenceExtension, portanto Name= , não é necessária quando x:Reference aparece em chaves curvas.

A x:Reference extensão de marcação é usada exclusivamente com associações de dados, que são descritas em mais detalhes no artigo Vinculação de dados.

A página x:Reference Demo mostra dois usos de com associações de x:Reference dados, o primeiro onde ele é usado para definir a Source propriedade do objeto e o segundo onde é usado para definir a BindingContext propriedade para duas associações de Binding dados:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="MarkupExtensions.ReferenceDemoPage"
             x:Name="page"
             Title="x:Reference Demo">

    <StackLayout Margin="10, 0">

        <Label Text="{Binding Source={x:Reference page},
                              StringFormat='The type of this page is {0}'}"
               FontSize="18"
               VerticalOptions="CenterAndExpand"
               HorizontalTextAlignment="Center" />

        <Slider x:Name="slider"
                Maximum="360"
                VerticalOptions="Center" />

        <Label BindingContext="{x:Reference slider}"
               Text="{Binding Value, StringFormat='{0:F0}&#x00B0; rotation'}"
               Rotation="{Binding Value}"
               FontSize="24"
               HorizontalOptions="Center"
               VerticalOptions="CenterAndExpand" />

    </StackLayout>
</ContentPage>

Ambas as x:Reference expressões usam a ReferenceExtension versão abreviada do nome da classe e eliminam a Name= parte da expressão. No primeiro exemplo, a x:Reference extensão de marcação é incorporada na Binding extensão de marcação. Observe que as configurações e StringFormat são separadas por vírgulasSource. Este é o programa em execução:

x:Extensão de marcação de tipo

A x:Type extensão de marcação é o equivalente XAML da palavra-chave C# typeof . Ele é suportado TypeExtension pela classe, que define uma propriedade chamada TypeName de tipo string que é definida como um nome de classe ou estrutura. A x:Type extensão de marcação retorna o System.Type objeto dessa classe ou estrutura. TypeName é a propriedade de conteúdo do TypeExtension, por isso TypeName= não é necessário quando x:Type aparece com chaves encaracoladas.

Dentro Xamarin.Formsdo , há várias propriedades que possuem argumentos do tipo Type. Os exemplos incluem a TargetType propriedade de Style, e o atributo x:TypeArguments usado para especificar argumentos em classes genéricas. No entanto, o analisador XAML executa a typeof operação automaticamente e a extensão de x:Type marcação não é usada nesses casos.

Um lugar onde x:Typeé necessário é com a extensão de x:Array marcação, que é descrita na próxima seção.

A x:Type extensão de marcação também é útil ao construir um menu onde cada item de menu corresponde a um objeto de um tipo específico. Você pode associar um Type objeto a cada item de menu e, em seguida, instanciar o objeto quando o item de menu é selecionado.

É assim que funciona o menu de navegação no MainPage programa Markup Extensions. O arquivo MainPage.xaml contém um TableView com cada TextCell correspondente a uma página específica no programa:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:local="clr-namespace:MarkupExtensions"
             x:Class="MarkupExtensions.MainPage"
             Title="Markup Extensions"
             Padding="10">
    <TableView Intent="Menu">
        <TableRoot>
            <TableSection>
                <TextCell Text="x:Static Demo"
                          Detail="Access constants or statics"
                          Command="{Binding NavigateCommand}"
                          CommandParameter="{x:Type local:StaticDemoPage}" />

                <TextCell Text="x:Reference Demo"
                          Detail="Reference named elements on the page"
                          Command="{Binding NavigateCommand}"
                          CommandParameter="{x:Type local:ReferenceDemoPage}" />

                <TextCell Text="x:Type Demo"
                          Detail="Associate a Button with a Type"
                          Command="{Binding NavigateCommand}"
                          CommandParameter="{x:Type local:TypeDemoPage}" />

                <TextCell Text="x:Array Demo"
                          Detail="Use an array to fill a ListView"
                          Command="{Binding NavigateCommand}"
                          CommandParameter="{x:Type local:ArrayDemoPage}" />

                ···                          

        </TableRoot>
    </TableView>
</ContentPage>

Aqui está a página principal de abertura em Extensões de marcação:

Cada CommandParameter propriedade é definida como uma x:Type extensão de marcação que faz referência a uma das outras páginas. A Command propriedade está vinculada a uma propriedade chamada NavigateCommand. Essa propriedade é definida no MainPage arquivo code-behind:

public partial class MainPage : ContentPage
{
    public MainPage()
    {
        InitializeComponent();

        NavigateCommand = new Command<Type>(async (Type pageType) =>
        {
            Page page = (Page)Activator.CreateInstance(pageType);
            await Navigation.PushAsync(page);
        });

        BindingContext = this;
    }

    public ICommand NavigateCommand { private set; get; }
}

A NavigateCommand propriedade é um Command objeto que implementa um comando execute com um argumento do tipo Type — o valor de CommandParameter. O método usa Activator.CreateInstance para instanciar a página e, em seguida, navega até ela. O construtor conclui definindo o BindingContext da página para si mesmo, o que permite que o Binding on Command funcione. Consulte o artigo Vinculação de dados e, particularmente, o artigo Comando para obter mais detalhes sobre esse tipo de código.

A página de demonstração x:Type usa uma técnica semelhante para instanciar Xamarin.Forms elementos e adicioná-los a um StackLayoutarquivo . O arquivo XAML inicialmente consiste em três Button elementos com suas Command propriedades definidas como a e as CommandParameter propriedades definidas como tipos Binding de três Xamarin.Forms modos de exibição:

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

    <StackLayout x:Name="stackLayout"
                 Padding="10, 0">

        <Button Text="Create a Slider"
                HorizontalOptions="Center"
                VerticalOptions="CenterAndExpand"
                Command="{Binding CreateCommand}"
                CommandParameter="{x:Type Slider}" />

        <Button Text="Create a Stepper"
                HorizontalOptions="Center"
                VerticalOptions="CenterAndExpand"
                Command="{Binding CreateCommand}"
                CommandParameter="{x:Type Stepper}" />

        <Button Text="Create a Switch"
                HorizontalOptions="Center"
                VerticalOptions="CenterAndExpand"
                Command="{Binding CreateCommand}"
                CommandParameter="{x:Type Switch}" />
    </StackLayout>
</ContentPage>

O arquivo code-behind define e inicializa a CreateCommand propriedade:

public partial class TypeDemoPage : ContentPage
{
    public TypeDemoPage()
    {
        InitializeComponent();

        CreateCommand = new Command<Type>((Type viewType) =>
        {
            View view = (View)Activator.CreateInstance(viewType);
            view.VerticalOptions = LayoutOptions.CenterAndExpand;
            stackLayout.Children.Add(view);
        });

        BindingContext = this;
    }

    public ICommand CreateCommand { private set; get; }
}

O método que é executado quando um Button é pressionado cria uma nova instância do argumento, define sua VerticalOptions propriedade e a adiciona ao StackLayout. Os três Button elementos compartilham a página com modos de exibição criados dinamicamente:

x:Extensão de marcação de matriz

A x:Array extensão de marcação permite que você defina uma matriz na marcação. Ele é suportado ArrayExtension pela classe, que define duas propriedades:

• Type do tipo Type, que indica o tipo dos elementos na matriz.
• Items do tipo IList, que é uma coleção dos próprios itens. Esta é a propriedade de conteúdo do ArrayExtension.

A x:Array extensão de marcação em si nunca aparece em chaves encaracoladas. Em vez disso, x:Array as tags start e end delimitam a lista de itens. Defina a Type propriedade como uma x:Type extensão de marcação.

A página x:Array Demo mostra como usar x:Array para adicionar itens a um ListView definindo a ItemsSource propriedade como uma matriz:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="MarkupExtensions.ArrayDemoPage"
             Title="x:Array Demo Page">
    <ListView Margin="10">
        <ListView.ItemsSource>
            <x:Array Type="{x:Type Color}">
                <Color>Aqua</Color>
                <Color>Black</Color>
                <Color>Blue</Color>
                <Color>Fuchsia</Color>
                <Color>Gray</Color>
                <Color>Green</Color>
                <Color>Lime</Color>
                <Color>Maroon</Color>
                <Color>Navy</Color>
                <Color>Olive</Color>
                <Color>Pink</Color>
                <Color>Purple</Color>
                <Color>Red</Color>
                <Color>Silver</Color>
                <Color>Teal</Color>
                <Color>White</Color>
                <Color>Yellow</Color>
            </x:Array>
        </ListView.ItemsSource>

        <ListView.ItemTemplate>
            <DataTemplate>
                <ViewCell>
                    <BoxView Color="{Binding}"
                             Margin="3" />    
                </ViewCell>
            </DataTemplate>
        </ListView.ItemTemplate>
    </ListView>
</ContentPage>        

O ViewCell cria um simples BoxView para cada entrada de cor:

Há várias maneiras de especificar os itens individuais Color nessa matriz. Você pode usar uma extensão de x:Static marcação:

<x:Static Member="Color.Blue" />

Ou, você pode usar StaticResource para recuperar uma cor de um dicionário de recursos:

<StaticResource Key="myColor" />

No final deste artigo, você verá uma extensão de marcação XAML personalizada que também cria um novo valor de cor:

<local:HslColor H="0.5" S="1.0" L="0.5" />

Ao definir matrizes de tipos comuns, como cadeias de caracteres ou números, use as marcas listadas no artigo Passando argumentos do construtor para delimitar os valores.

x:Extensão de marcação nula

A x:Null extensão de marcação é suportada NullExtension pela classe. Ele não tem propriedades e é simplesmente o equivalente XAML da palavra-chave C# null .

A x:Null extensão de marcação raramente é necessária e raramente usada, mas se você encontrar uma necessidade para ela, ficará feliz que ela exista.

A página de demonstração x:Null ilustra um cenário quando x:Null pode ser conveniente. Suponha que você defina um implícito Style para Label que inclua um Setter que define a propriedade como um nome de família dependente da FontFamily plataforma:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="MarkupExtensions.NullDemoPage"
             Title="x:Null Demo">
    <ContentPage.Resources>
        <ResourceDictionary>
            <Style TargetType="Label">
                <Setter Property="FontSize" Value="48" />
                <Setter Property="FontFamily">
                    <Setter.Value>
                        <OnPlatform x:TypeArguments="x:String">
                            <On Platform="iOS" Value="Times New Roman" />
                            <On Platform="Android" Value="serif" />
                            <On Platform="UWP" Value="Times New Roman" />
                        </OnPlatform>
                    </Setter.Value>
                </Setter>
            </Style>
        </ResourceDictionary>
    </ContentPage.Resources>

    <ContentPage.Content>
        <StackLayout Padding="10, 0">
            <Label Text="Text 1" />
            <Label Text="Text 2" />

            <Label Text="Text 3"
                   FontFamily="{x:Null}" />

            <Label Text="Text 4" />
            <Label Text="Text 5" />
        </StackLayout>
    </ContentPage.Content>
</ContentPage>   

Em seguida, você descobre que, para um dos elementos, deseja todas as configurações de Label propriedade no implícito Style , exceto o FontFamily, que você deseja que seja o valor padrão. Você poderia definir outro Style para esse propósito, mas uma abordagem mais simples é simplesmente definir a FontFamily propriedade do particular Label para x:Null, como demonstrado no centro Label.

Este é o programa em execução:

Observe que quatro dos Label elementos têm uma fonte serifa, mas o centro Label tem a fonte sans-serif padrão.

Extensão de marcação OnPlatform

A extensão de marcação OnPlatform permite que você personalize a aparência da interface do usuário por plataforma. Ele fornece a mesma funcionalidade que as OnPlatform classes e On , mas com uma representação mais concisa.

A OnPlatform extensão de marcação é suportada OnPlatformExtension pela classe, que define as seguintes propriedades:

• Default do tipo object, que você define como um valor padrão a ser aplicado às propriedades que representam plataformas.
• Android do tipo object, que você define como um valor a ser aplicado no Android.
• GTK do tipo object, que você define como um valor a ser aplicado em plataformas GTK.
• iOS do tipo object, que você define como um valor a ser aplicado no iOS.
• macOS do tipo object, que você definiu como um valor a ser aplicado no macOS.
• Tizen do tipo object, que você define como um valor a ser aplicado na plataforma Tizen.
• UWP do tipo object, que você define como um valor a ser aplicado na Plataforma Universal do Windows.
• WPF do tipo object, que você define como um valor a ser aplicado na plataforma Windows Presentation Foundation.
• Converter do tipo IValueConverter, que pode ser definido como uma IValueConverter implementação.
• ConverterParameter do tipo object, que pode ser definido como um valor a ser passado para a IValueConverter implementação.

A Default propriedade é a propriedade content de OnPlatformExtension. Portanto, para expressões de marcação XAML expressas com chaves, você pode eliminar a Default= parte da expressão, desde que seja o primeiro argumento. Se a Default propriedade não estiver definida, ela assumirá como padrão o valor da BindableProperty.DefaultValue propriedade, desde que a extensão de marcação esteja direcionada a um BindablePropertyarquivo .

A página OnPlatform Demo mostra como usar a OnPlatform extensão de marcação:

<BoxView Color="{OnPlatform Yellow, iOS=Red, Android=Green, UWP=Blue}"
         WidthRequest="{OnPlatform 250, iOS=200, Android=300, UWP=400}"  
         HeightRequest="{OnPlatform 250, iOS=200, Android=300, UWP=400}"
         HorizontalOptions="Center" />

Neste exemplo, todas as três OnPlatform expressões usam a versão abreviada do nome da OnPlatformExtension classe. As três OnPlatform extensões de marcação definem as Colorpropriedades , WidthRequeste HeightRequest do BoxView para valores diferentes no iOS, Android e UWP. As extensões de marcação também fornecem valores padrão para essas propriedades nas plataformas que não são especificadas, enquanto eliminam a Default= parte da expressão. Observe que as propriedades de extensão de marcação definidas são separadas por vírgulas.

Este é o programa em execução:

Extensão de marcação OnIdiom

A OnIdiom extensão de marcação permite personalizar a aparência da interface do usuário com base no idioma do dispositivo em que o aplicativo está sendo executado. Ele é suportado OnIdiomExtension pela classe, que define as seguintes propriedades:

• Default do tipo object, que você define como um valor padrão a ser aplicado às propriedades que representam expressões idiomáticas do dispositivo.
• Phone do tipo object, que você define como um valor a ser aplicado em telefones.
• Tablet do tipo object, que você define como um valor a ser aplicado em tablets.
• Desktop do tipo object, que você define como um valor a ser aplicado em plataformas de desktop.
• TV do tipo object, que você define como um valor a ser aplicado em plataformas de TV.
• Watch do tipo object, que você define como um valor a ser aplicado em plataformas Watch.
• Converter do tipo IValueConverter, que pode ser definido como uma IValueConverter implementação.
• ConverterParameter do tipo object, que pode ser definido como um valor a ser passado para a IValueConverter implementação.

A Default propriedade é a propriedade content de OnIdiomExtension. Portanto, para expressões de marcação XAML expressas com chaves, você pode eliminar a Default= parte da expressão, desde que seja o primeiro argumento.

A página OnIdiom Demo mostra como usar a extensão de OnIdiom marcação:

<BoxView Color="{OnIdiom Yellow, Phone=Red, Tablet=Green, Desktop=Blue}"
         WidthRequest="{OnIdiom 100, Phone=200, Tablet=300, Desktop=400}"
         HeightRequest="{OnIdiom 100, Phone=200, Tablet=300, Desktop=400}"
         HorizontalOptions="Center" />

Neste exemplo, todas as três OnIdiom expressões usam a versão abreviada do nome da OnIdiomExtension classe. As três OnIdiom extensões de marcação definem o Color, WidthRequeste HeightRequest as propriedades do BoxView para valores diferentes nos idiomas do telefone, tablet e desktop. As extensões de marcação também fornecem valores padrão para essas propriedades nos idiomas que não são especificados, enquanto eliminam a Default= parte da expressão. Observe que as propriedades de extensão de marcação definidas são separadas por vírgulas.

Este é o programa em execução:

Extensão de marcação DataTemplate

A DataTemplate extensão de marcação permite converter um tipo em um DataTemplatearquivo . Ele é suportado DataTemplateExtension pela classe, que define uma TypeName propriedade, do tipo string, que é definida como o nome do tipo a ser convertido em um DataTemplatearquivo . A TypeName propriedade é a propriedade content de DataTemplateExtension. Portanto, para expressões de marcação XAML expressas com chaves curvas, você pode eliminar a TypeName= parte da expressão.

Um uso típico dessa extensão de marcação está em um aplicativo Shell, conforme mostrado no exemplo a seguir:

<ShellContent Title="Monkeys"
              Icon="monkey.png"
              ContentTemplate="{DataTemplate views:MonkeysPage}" />

Neste exemplo, MonkeysPage é convertido de um ContentPage para um DataTemplate, que é definido como o valor da ShellContent.ContentTemplate propriedade. Isso garante que MonkeysPage seja criado somente quando a navegação para a página ocorrer, em vez de na inicialização do aplicativo.

Para obter mais informações sobre aplicativos do Shell, consulte Xamarin.Forms Shell.

Extensão de marcação FontImage

A FontImage extensão de marcação permite que você exiba um ícone de fonte em qualquer modo de exibição que possa exibir um ImageSourcearquivo . Ele fornece a mesma funcionalidade que a FontImageSource classe, mas com uma representação mais concisa.

A FontImage extensão de marcação é suportada FontImageExtension pela classe, que define as seguintes propriedades:

• FontFamily do tipo string, a família de fontes à qual o ícone de fonte pertence.
• Glyph do tipo string, o valor do caractere unicode do ícone de fonte.
• Color do tipo Color, a cor a ser usada ao exibir o ícone de fonte.
• Size do tipo double, o tamanho, em unidades independentes do dispositivo, do ícone de fonte renderizada. O valor padrão é 30. Além disso, essa propriedade pode ser definida como um tamanho de fonte nomeado.

A Glyph propriedade é a propriedade content de FontImageExtension. Portanto, para expressões de marcação XAML expressas com chaves, você pode eliminar a Glyph= parte da expressão, desde que seja o primeiro argumento.

A página de demonstração FontImage mostra como usar a extensão de FontImage marcação:

<Image BackgroundColor="#D1D1D1"
       Source="{FontImage &#xf30c;, FontFamily={OnPlatform iOS=Ionicons, Android=ionicons.ttf#}, Size=44}" />

Neste exemplo, a FontImageExtension versão abreviada do nome da classe é usada para exibir um ícone XBox, da família de fontes Ionicons, em um Imagearquivo . A expressão também usa a OnPlatform extensão de marcação para especificar valores de propriedade diferentes FontFamily no iOS e no Android. Além disso, a Glyph= parte da expressão é eliminada e as propriedades de extensão de marcação definidas são separadas por vírgulas. Observe que, embora o caractere unicode do ícone seja \uf30c, ele precisa ser escapado em XAML e, portanto, se torna .

Este é o programa em execução:

Para obter informações sobre como exibir ícones de fonte especificando os dados do ícone de fonte em um FontImageSource objeto, consulte Exibir ícones de fonte.

Extensão de marcação AppThemeBinding

A AppThemeBinding extensão de marcação permite especificar um recurso a ser consumido, como uma imagem ou cor, com base no tema do sistema atual.

A AppThemeBinding extensão de marcação é suportada AppThemeBindingExtension pela classe, que define as seguintes propriedades:

• Default, do tipo object, que você definiu como o recurso a ser usado por padrão.
• Light, do tipo object, que você define como o recurso a ser usado quando o dispositivo estiver usando seu tema claro.
• Dark, do tipo object, que você define como o recurso a ser usado quando o dispositivo estiver usando seu tema escuro.
• Value, do tipo object, que retorna o recurso que está sendo usado atualmente pela extensão de marcação.

A Default propriedade é a propriedade content de AppThemeBindingExtension. Portanto, para expressões de marcação XAML expressas com chaves, você pode eliminar a Default= parte da expressão, desde que seja o primeiro argumento.

A página de demonstração AppThemeBinding mostra como usar a extensão de AppThemeBinding marcação:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="MarkupExtensions.AppThemeBindingDemoPage"
             Title="AppThemeBinding Demo">
    <ContentPage.Resources>

        <Style x:Key="labelStyle"
               TargetType="Label">
            <Setter Property="TextColor"
                    Value="{AppThemeBinding Black, Light=Blue, Dark=Teal}" />
        </Style>

    </ContentPage.Resources>
    <StackLayout Margin="20">
        <Label Text="This text is green in light mode, and red in dark mode."
               TextColor="{AppThemeBinding Light=Green, Dark=Red}" />
        <Label Text="This text is black by default, blue in light mode, and teal in dark mode."
               Style="{StaticResource labelStyle}" />
    </StackLayout>
</ContentPage>

Neste exemplo, a cor do texto do primeiro Label é definida como verde quando o dispositivo está usando seu tema claro e é definida como vermelho quando o dispositivo está usando seu tema escuro. O segundo Label tem sua TextColor propriedade definida através de um Stylearquivo . Isso Style define a cor do Label texto como preto por padrão, azul quando o dispositivo está usando seu tema claro e azul-marinho quando o dispositivo está usando seu tema escuro.

Este é o programa em execução:

Definir extensões de marcação

Se você encontrou a necessidade de uma extensão de marcação XAML que não está disponível no Xamarin.Forms, você pode criar o seu próprio.

Links relacionados

• Capítulo de extensões de marcação XAML do Xamarin.Forms livro
• Dicionários de recurso
• Estilos dinâmicos
• Associação de dados
• Xamarin.Forms Concha
• Responder a alterações de tema do sistema em Xamarin.Forms aplicativos