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

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

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

No momento da 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 atualizar-se com base nessas alterações (Mode="OneWay"). Ele pode ser configurado, opcionalmente, para enviar atualizações de volta ao valor da propriedade de origem (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 a inspeção de objeto de runtime de uso geral. Consequentemente, as associações {x:Bind} (geralmente conhecidas como associações compiladas) têm um ó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 que são gerados como a classe parcial para sua página. Esses arquivos podem ser encontrados em sua obj pasta, com nomes como (para C#) <view name>.g.cs.

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 exemplo de XAML 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} . Path é um caminho de propriedade que especifica o valor da propriedade, sub-propriedade, 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 omitir: {x:Bind ...}.

Resolução do caminho da propriedade

{x:Bind} 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 buscará no code-behind da sua página ou controle de usuário por propriedades, campos e métodos. Para expor seu modelo de exibição a {x:Bind}, você normalmente desejará adicionar novos campos ou propriedades ao código por trás de sua página ou controle de usuário. Os passos em um caminho de propriedade são delimitados por pontos (.) e você pode incluir vários delimitadores para percorrer sucessivas subpropriedades. Use o delimitador de ponto independentemente da linguagem de programação usada para implementar o objeto ao qual está associado.

Por exemplo: em uma página, Text="{x:Bind Employee.FirstName}" procurará um membro funcionário na página e, em seguida, um membro FirstName no objeto retornado pelo Funcionário. Se você estiver associando um controle de itens a uma propriedade que contenha os dependentes de um funcionário, seu caminho de propriedade poderá ser "Employee.Dependents" e o modelo de item do controle de itens cuidará da exibição dos itens em "Dependentes".

Para C++/CX, {x:Bind} não pode associar a campos e propriedades privados na página ou no modelo de dados. Você precisará ter uma propriedade pública para que ela seja associável. A área de superfície para associação precisa ser exposta como classes/interfaces CX para que possamos obter os metadados relevantes. O atributo [Associável] não deveria 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 controle de usuário que representa a origem da associação raiz.

Collections

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 "[]" contém 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, ele registrará e escutará as 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. O chapéu (^) pode ser usado para escapar de aspas em cadeias de caracteres. 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 string, o modelo precisa implementar IDictionary<string, T> ou IMap<string, T> no tipo da propriedade que será indexada. Se o tipo da propriedade indexada der suporte a IObservableMap e a vinculação for OneWay ou TwoWay, ele 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 vincular às propriedades anexadas, você precisa colocar a classe e o nome da propriedade em parênteses após o ponto final. 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 deverá ser mapeado para um namespace de código à frente do documento.

Elenco

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á no momento da compilação. Você pode especificar uma conversão de tipo para indicar a vinculação com o tipo verdadeiro do objeto.

No caso a seguir, o obj é uma propriedade do objeto type, mas contém uma caixa de texto, portanto, podemos usar Text="{x:Bind ((TextBox)obj). Text}" ou Text="{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 de namespace data: do xml para mapear o tipo de objeto para um namespace de código que é distinto do namespace XAML padrão.

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

Conversão sem rota

O analisador de associação nativa 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 executar 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

A partir do Windows 10, versão 1607, {x:Bind} oferece suporte ao uso de uma função como a etapa final do caminho de ligação. Esse é um recurso avançado para vinculação de dados que permite vários cenários na marcação. Confira as associações de função para obter detalhes.

Vinculação de Eventos

A vinculação de eventos é um recurso exclusivo para vinculação compilada. Ele permite que você especifique o manipulador para 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:

• Corresponda à assinatura do evento.
• OU não tem parâmetros.
• OU tem o mesmo número de parâmetros de tipos que são atribuíveis dos tipos dos parâmetros de evento.

No code-behind gerado, a vinculação compilada manipula o evento e o direciona para o método no modelo, avaliando o caminho da expressão de vinculação quando o evento acontece. Isso significa que, ao contrário das vinculações de propriedade, ela não acompanha 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:Bind} é ilustrado com a sintaxe de espaço reservado bindingProperties porque existem várias propriedades de leitura/gravação que podem ser configuradas na extensão de marcação. As propriedades podem ser definidas em qualquer ordem com pares devalor= 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, elas exigem extensões de marcação próprias aninhadas no {x:Bind}.

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

Observações

Como {x:Bind} usa o 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 Objeto, 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 associado definindo um valor x:DataType , conforme mostrado na seção Exemplos . Você também pode definir o tipo para uma interface ou tipo de classe base e, em seguida, usar casting, 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. Isso inclui os seguintes métodos:

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

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

{x:Bind} é 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 a visão geral do XAML.