Funções em 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 obter uma comparação completa entre {x:Bind} e {Binding}), consulte Associação de dados em detalhada e de Extensão de Marcação {x:Bind} .

A partir do Windows 10, versão 1607, {x:Bind} suporta o uso de uma função como etapa final do caminho de associação. Isso permite:

• Uma maneira mais simples de obter a conversão de valor
• Uma maneira de as associações dependerem de mais de um parâmetro

Observação

Para usar funções com {x:Bind}, a versão mínima do SDK de destino do aplicativo deve ser 14393 ou posterior. Você não pode usar funções quando seu aplicativo é direcionado a versões anteriores do Windows 10. Para obter mais informações sobre versões de destino, consulte código de versão adaptável.

No exemplo a seguir, a tela de fundo e o primeiro plano do item são associados a funções para fazer conversão com base no parâmetro de cor

<DataTemplate x:DataType="local:ColorEntry">
    <Grid Background="{x:Bind local:ColorEntry.Brushify(Color), Mode=OneWay}" Width="240">
        <TextBlock Text="{x:Bind ColorName}" Foreground="{x:Bind TextColor(Color)}" Margin="10,5" />
    </Grid>
</DataTemplate>

class ColorEntry
{
    public string ColorName { get; set; }
    public Color Color { get; set; }

    public static SolidColorBrush Brushify(Color c)
    {
        return new SolidColorBrush(c);
    }

    public SolidColorBrush TextColor(Color c)
    {
        return new SolidColorBrush(((c.R * 0.299 + c.G * 0.587 + c.B * 0.114) > 150) ? Colors.Black : Colors.White);
    }
}

Uso do atributo XAML

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

Caminho para a função

O caminho para a função é especificado da mesma forma que outros caminhos de propriedade e pode incluir pontos (.), indexadores ou conversões de tipo para localizar a função.

As funções estáticas podem ser especificadas usando a sintaxe XMLNamespace:ClassName.MethodName. Por exemplo, use a sintaxe abaixo para vincular a funções estáticas no arquivo de código subjacente.

<Page 
     xmlns:local="using:MyNamespace">
     ...
    <StackPanel>
        <TextBlock x:Name="BigTextBlock" FontSize="20" Text="Big text" />
        <TextBlock FontSize="{x:Bind local:MyHelpers.Half(BigTextBlock.FontSize)}" 
                   Text="Small text" />
    </StackPanel>
</Page>

namespace MyNamespace
{
    static public class MyHelpers
    {
        public static double Half(double value) => value / 2.0;
    }
}

Você também pode usar funções do sistema diretamente na marcação para realizar cenários simples como formatação de data, formatação de texto, concatenações de texto etc., por exemplo:

<Page 
     xmlns:sys="using:System"
     xmlns:local="using:MyNamespace">
     ...
     <CalendarDatePicker Date="{x:Bind sys:DateTime.Parse(TextBlock1.Text)}" />
     <TextBlock Text="{x:Bind sys:String.Format('{0} is now available in {1}', local:MyPage.personName, local:MyPage.location)}" />
</Page>

Se o modo for OneWay/TwoWay, será realizada uma detecção de alterações no caminho da função, e a associação será reavaliada no caso de haver alterações nesses objetos.

A função que está sendo vinculada precisa:

• Seja acessível ao código e metadados – portanto, trabalho interno/privado em C#, mas C++/CX precisará de métodos para serem métodos winRT públicos
• A sobrecarga é baseada no número de argumentos, não no tipo, e tentará corresponder à primeira sobrecarga com tantos argumentos
• Os tipos de argumento precisam corresponder aos dados que estão sendo passados – não fazemos conversões de restrição
• O tipo de retorno da função precisa corresponder ao tipo da propriedade que está usando a associação

O mecanismo de associação reage às notificações de alteração de propriedade disparadas com o nome da função e reavalia as associações conforme necessário. Por exemplo:

<DataTemplate x:DataType="local:Person">
   <StackPanel>
      <TextBlock Text="{x:Bind FullName}" />
      <Image Source="{x:Bind IconToBitmap(Icon, CancellationToken), Mode=OneWay}" />
   </StackPanel>
</DataTemplate>

public class Person : INotifyPropertyChanged
{
    //Implementation for an Icon property and a CancellationToken property with PropertyChanged notifications
    ...

    //IconToBitmap function is essentially a multi binding converter between several options.
    public Uri IconToBitmap (Uri icon, Uri cancellationToken)
    {
        Uri foo = new Uri(...);        
        if (isCancelled)
        {
            foo = cancellationToken;
        }
        else 
        {
            if (this.fullName.Contains("Sr"))
            {
               //pass a different Uri back
               foo = new Uri(...);
            }
            else
            {
                foo = icon;
            }
        }
        return foo;
    }

    //Ensure FullName property handles change notification on itself as well as IconToBitmap since the function uses it
    public string FullName
    {
        get { return this.fullName; }
        set
        {
            this.fullName = value;
            this.OnPropertyChanged ();
            this.OnPropertyChanged ("IconToBitmap"); 
            //this ensures Image.Source binding re-evaluates when FullName changes in addition to Icon and CancellationToken
        }
    }
}

Dica

Você pode usar funções em x:Bind para realizar os mesmos cenários que eram suportados através de Conversores e MultiBinding no WPF.

Argumentos de função

Vários argumentos de função podem ser especificados, separados por vírgula (,)

• Caminho de Associação – mesma sintaxe que se você estivesse associando diretamente a esse objeto.
  • Se o modo for OneWay/TwoWay, a detecção de alterações será executada e a associação será reavaliada após alterações de objeto
• Cadeia de caracteres constante entre aspas – aspas são necessárias para designá-la como uma cadeia de caracteres. O chapéu (^) pode ser usado para escapar de aspas em cadeias de caracteres
• Número constante - por exemplo -123.456
• Booliano – especificado como "x:True" ou "x:False"

Dica

TargetNullValue será aplicado ao resultado da chamada de função, não a argumentos associados.

Vinculações de função bidirecional

Em um cenário de associação bidirecional, uma segunda função deve ser especificada para a direção inversa da associação. Isso é feito usando a propriedade de associação BindBack. No exemplo abaixo, a função deve usar um argumento que é o valor que precisa ser enviado de volta para o modelo.

<TextBlock Text="{x:Bind a.MyFunc(b), BindBack=a.MyFunc2, Mode=TwoWay}" />

Consulte também

• Extensão de Marcação {x:Bind}