Extensão de marcação {x:Bind}

Observação Para obter informações gerais sobre como usar a associação de dados em seu aplicativo com {x:Bind} (e para uma comparação completa entre {x:Bind} e {Binding}), consulte Associação de dados em detalhes.

A extensão de marcação {x:Bind} , nova para Windows 10, é uma alternativa a {Binding}. {x:Vincular} é executado em menos tempo e menos memória do que {Binding} e dá suporte a uma melhor depuração.

Em tempo de compilação XAML, {x:Bind} é convertido em código que obterá um valor de uma propriedade em uma fonte de dados e o definirá na propriedade especificada na marcação. Opcionalmente, o objeto de associação pode ser configurado para observar alterações no valor da propriedade da fonte de dados e se atualizar com base nessas alterações (Mode="OneWay"). Opcionalmente, ele também pode ser configurado para enviar alterações em seu próprio valor de volta para a propriedade source (Mode="TwoWay").

Os objetos de associação criados por {x:Bind} e {Binding} são em grande parte funcionalmente equivalentes. Mas {x:Bind} executa código de finalidade especial, que ele gera em tempo de compilação, e {Binding} usa inspeção de objeto de runtime de uso geral. Consequentemente, as associações {x:Bind} (geralmente chamadas de associações compiladas) têm ótimo desempenho, fornecem validação em tempo de compilação de suas expressões de associação e dão suporte à depuração, permitindo que você defina pontos de interrupção nos arquivos de código gerados como a classe parcial para sua página. Esses arquivos podem ser encontrados em sua pasta obj, com nomes como (para C#) <view name>.g.cs.

Aplicativos de amostra que demonstram {x:Bind}

• {x:Bind} exemplo
• QuizGame
• Galeria de controles XAML

Uso do atributo XAML

<object property="{x:Bind}" .../>
-or-
<object property="{x:Bind propertyPath}" .../>
-or-
<object property="{x:Bind bindingProperties}" .../>
-or-
<object property="{x:Bind propertyPath, bindingProperties}" .../>
-or-
<object property="{x:Bind pathToFunction.functionName(functionParameter1, functionParameter2, ...), bindingProperties}" .../>

Exemplos

<Page x:Class="QuizGame.View.HostView" ... >
    <Button Content="{x:Bind Path=ViewModel.NextButtonText, Mode=OneWay}" ... />
</Page>

Este XAML de exemplo usa {x:Bind} com uma propriedade ListView.ItemTemplate . Observe a declaração de um valor x:DataType .

  <DataTemplate x:Key="SimpleItemTemplate" x:DataType="data:SampleDataGroup">
    <StackPanel Orientation="Vertical" Height="50">
      <TextBlock Text="{x:Bind Title}"/>
      <TextBlock Text="{x:Bind Description}"/>
    </StackPanel>
  </DataTemplate>

Caminho da propriedade

PropertyPath define o caminho para uma expressão {x:Bind} . Caminho é um caminho de propriedade que especifica o valor da propriedade, subpropriedade, campo ou método ao qual você está associando (a origem). Você pode mencionar o nome da propriedade Path explicitamente: {x:Bind Path=...}. Ou você pode omiti-lo: {x:Bind ...}.

Resolução do caminho da propriedade

{x:Vincular} não usa o DataContext como uma fonte padrão — em vez disso, ele usa a página ou o próprio controle de usuário. Portanto, ele procurará propriedades, campos e métodos no code-behind de sua página ou controle de usuário. Para expor seu modelo de exibição a {x:Bind}, você normalmente desejará adicionar novos campos ou propriedades ao code-behind para sua página ou controle de usuário. As etapas em um caminho de propriedade são delimitadas por pontos (.), e você pode incluir vários delimitadores para percorrer subpropriedades sucessivas. Use o delimitador de pontos, independentemente da linguagem de programação usada para implementar o objeto ao qual está sendo associado.

Por exemplo: em uma página, Text="{x:Bind Employee.FirstName}" procurará um membro Employee na página e, em seguida, um membro FirstName no objeto retornado por Employee. Se você estiver associando um controle de itens a uma propriedade que contém os dependentes de um funcionário, o caminho da propriedade poderá ser "Employee.Dependents" e o modelo de item do controle de itens se encarregará de exibir os itens em "Dependentes".

Para C++/CX, {x:Bind} não pode ser associado a campos e propriedades privados na página ou no modelo de dados – você precisará ter uma propriedade pública para que ele possa ser associado. A área de superfície para associação precisa ser exposta como classes/interfaces CX para que possamos obter os metadados relevantes. O atributo [Bindable] não deve ser necessário.

Com x:Bind, você não precisa usar ElementName=xxx como parte da expressão de associação. Em vez disso, você pode usar o nome do elemento como a primeira parte do caminho para a associação porque os elementos nomeados se tornam campos dentro da página ou do controle de usuário que representa a origem da associação raiz.

Coleções

Se a fonte de dados for uma coleção, um caminho de propriedade poderá especificar itens na coleção por sua posição ou índice. Por exemplo, "Teams[0]. Players", onde o literal "[]" inclui o "0" que solicita o primeiro item em uma coleção indexada a zero.

Para usar um indexador, o modelo precisa implementar IList<T> ou IVector<T> no tipo da propriedade que será indexada. (Observe que IReadOnlyList<T> e IVectorView<T> não dão suporte à sintaxe do indexador.) Se o tipo da propriedade indexada der suporte a INotifyCollectionChanged ou IObservableVector e a associação for OneWay ou TwoWay, ela se registrará e escutará notificações de alteração nessas interfaces. A lógica de detecção de alterações será atualizada com base em todas as alterações de coleção, mesmo que isso não afete o valor indexado específico. Isso ocorre porque a lógica de escuta é comum em todas as instâncias da coleção.

Se a fonte de dados for um Dicionário ou Mapa, um caminho de propriedade poderá especificar itens na coleção pelo nome da cadeia de caracteres. Por exemplo <, TextBlock Text="{x:Bind Players['John Smith']}" /> procurará um item no dicionário chamado "John Smith". O nome precisa ser colocado entre aspas e aspas simples ou duplas podem ser usadas. Hat (^) pode ser usado para escapar aspas em strings. Geralmente, é mais fácil usar aspas alternativas daquelas usadas para o atributo XAML. (Observe que IReadOnlyDictionary<T> e IMapView<T> não dão suporte à sintaxe do indexador.)

Para usar um indexador de cadeia de caracteres, o modelo precisa implementar a cadeia de caracteres IDictionary<, a cadeia de caracteres T> ou IMap<, T> no tipo da propriedade que será indexada. Se o tipo da propriedade indexada der suporte a IObservableMap e a associação for OneWay ou TwoWay, ela se registrará e escutará notificações de alteração nessas interfaces. A lógica de detecção de alterações será atualizada com base em todas as alterações de coleção, mesmo que isso não afete o valor indexado específico. Isso ocorre porque a lógica de escuta é comum em todas as instâncias da coleção.

Propriedades Anexadas

Para associar a propriedades anexadas, você precisa colocar a classe e o nome da propriedade entre parênteses após o ponto. Por exemplo, Text="{x:Bind Button22.( Grid.Row)}". Se a propriedade não for declarada em um namespace Xaml, você precisará prefixá-la com um namespace xml, que deve ser mapeado para um namespace de código no cabeçalho do documento.

Transmissão

As associações compiladas são fortemente tipadas e resolverão o tipo de cada etapa em um caminho. Se o tipo retornado não tiver o membro, ele falhará em tempo de compilação. Você pode especificar uma conversão para informar à associação o tipo real do objeto.

No caso a seguir, obj é uma propriedade do tipo object, mas contém uma caixa de texto, portanto, podemos usar Text="{x:Bind ((TextBox)obj). Texto}" ou Texto="{x:Bind obj.(TextBox.Text)}".

O campo groups3 em Text="{x:Bind ((data:SampleDataGroup)groups3[0]). Title}" é um dicionário de objetos, portanto, você deve convertê-lo em data:SampleDataGroup. Observe o uso do prefixo xml data: namespace para mapear o tipo de objeto para um namespace de código que não faz parte do namespace XAML padrão.

Observação: a sintaxe de conversão no estilo C# é mais flexível do que a sintaxe de propriedade anexada e é a sintaxe recomendada daqui para frente.

Lançamento sem caminho

O analisador de associação nativo não fornece uma palavra-chave para representar this como um parâmetro de função, mas dá suporte à conversão sem caminho (por exemplo, {x:Bind (x:String)}), que pode ser usada como um parâmetro de função. Portanto, {x:Bind MethodName((namespace:TypeOfThis))} é uma maneira válida de realizar o que é conceitualmente equivalente a {x:Bind MethodName(this)}.

Exemplo:

Text="{x:Bind local:MainPage.GenerateSongTitle((local:SongItem))}"

<Page
    x:Class="AppSample.MainPage"
    ...
    xmlns:local="using:AppSample">

    <Grid>
        <ListView ItemsSource="{x:Bind Songs}">
            <ListView.ItemTemplate>
                <DataTemplate x:DataType="local:SongItem">
                    <TextBlock
                        Margin="12"
                        FontSize="40"
                        Text="{x:Bind local:MainPage.GenerateSongTitle((local:SongItem))}" />
                </DataTemplate>
            </ListView.ItemTemplate>
        </ListView>
    </Grid>
</Page>

namespace AppSample
{
    public class SongItem
    {
        public string TrackName { get; private set; }
        public string ArtistName { get; private set; }

        public SongItem(string trackName, string artistName)
        {
            ArtistName = artistName;
            TrackName = trackName;
        }
    }

    public sealed partial class MainPage : Page
    {
        public List<SongItem> Songs { get; }
        public MainPage()
        {
            Songs = new List<SongItem>()
            {
                new SongItem("Track 1", "Artist 1"),
                new SongItem("Track 2", "Artist 2"),
                new SongItem("Track 3", "Artist 3")
            };

            this.InitializeComponent();
        }

        public static string GenerateSongTitle(SongItem song)
        {
            return $"{song.TrackName} - {song.ArtistName}";
        }
    }
}

Funções em caminhos de associação

Desde o Windows 10, versão 1607, {x: Bind} dá suporte ao uso de uma função como a etapa de folha do caminho de associação. Esse é um recurso poderoso para vinculação de dados que permite vários cenários na marcação. Consulte associações de função para obter detalhes.

Associação de eventos

A associação de eventos é um recurso exclusivo para associação compilada. Ele permite que você especifique o manipulador de um evento usando uma associação, em vez de ter que ser um método no code-behind. Por exemplo: Click="{x:Bind rootFrame.GoForward}".

Para eventos, o método de destino não deve ser sobrecarregado e também deve:

• Combine a assinatura do evento.
• OU não têm parâmetros.
• OU têm o mesmo número de parâmetros de tipos que podem ser atribuídos a partir dos tipos dos parâmetros de evento.

No code-behind gerado, a associação compilada manipula o evento e o encaminha para o método no modelo, avaliando o caminho da expressão de associação quando o evento ocorre. Isso significa que, ao contrário das associações de propriedade, ele não rastreia as alterações no modelo.

Para obter mais informações sobre a sintaxe de cadeia de caracteres para um caminho de propriedade, consulte Sintaxe de caminho de propriedade, tendo em mente as diferenças descritas aqui para {x:Bind}.

Propriedades que você pode definir com {x:Bind}

{x:Vincular} é ilustrado com a sintaxe de espaço reservado bindingProperties porque há várias propriedades de leitura/gravação que podem ser definidas na extensão de marcação. As propriedades podem ser definidas em qualquer ordem com pares de valores propName=separados por vírgulas. Observe que você não pode incluir quebras de linha na expressão de associação. Algumas das propriedades exigem tipos que não têm uma conversão de tipo, portanto, exigem extensões de marcação próprias aninhadas no {x:Bind}.

Essas propriedades funcionam da mesma maneira que as propriedades da classe Binding.

Comentários

Como {x:Bind} usa código gerado para obter seus benefícios, ele requer informações de tipo em tempo de compilação. Isso significa que você não pode associar a propriedades em que não conhece o tipo com antecedência. Por isso, você não pode usar {x:Bind} com a propriedade DataContext , que é do tipo Object e também está sujeita a alterações em tempo de execução.

Ao usar {x:Bind} com modelos de dados, você deve indicar o tipo que está sendo associado definindo um valor x:DataType , conforme mostrado na seção Exemplos . Você também pode definir o tipo como uma interface ou tipo de classe base e, em seguida, usar conversões, se necessário, para formular uma expressão completa.

As associações compiladas dependem da geração de código. Portanto, se você usar {x:Bind} em um dicionário de recursos, o dicionário de recursos precisará ter uma classe code-behind. Consulte Dicionários de recursos com {x:Bind} para obter um exemplo de código.

Páginas e controles de usuário que incluem associações compiladas terão uma propriedade "Bindings" no código gerado. Entre elas estão os seguintes métodos:

• Update() - Isso atualizará os valores de todas as associações compiladas. Qualquer associação unidirecional/bidirecional terá os ouvintes conectados para detectar alterações.
• Initialize() - Se as ligações ainda não tiverem sido inicializadas, ele chamará Update() para inicializar as ligações
• StopTracking() - Isso desconectará todos os ouvintes criados para associações unidirecionais e bidirecionais. Eles podem ser reinicializados usando o método Update().

Dica Se você precisar especificar uma única chave para um valor, como em Path ou ConverterParameter, preceda-a com uma barra invertida: . \{ Como alternativa, coloque toda a cadeia de caracteres que contém as chaves que precisam ser escapadas em um conjunto de aspas secundário, por exemplo ConverterParameter='{Mix}'.

Converter, ConverterLanguage e ConverterLanguage estão todos relacionados ao cenário de conversão de um valor ou tipo da origem da associação em um tipo ou valor compatível com a propriedade de destino da associação. Para obter mais informações e exemplos, consulte a seção "Conversões de dados" de Associação de dados em detalhes.

{x:Vincular} é apenas uma extensão de marcação, sem nenhuma maneira de criar ou manipular essas associações programaticamente. Para obter mais informações sobre extensões de marcação, consulte Visão geral do XAML.