Condividi tramite

Funzioni in x:Bind

Annotazioni

Per informazioni generali sull'uso del data binding nell'app con {x:Bind} (e per un confronto all-up tra {x:Bind} e {Binding}), vedere Data binding approfondito e {x:Bind} Estensione di markup.

A partire da Windows 10 versione 1607, {x:Bind} supporta l'uso di una funzione come passo finale del percorso di associazione. In questo modo è possibile:

  • Un modo più semplice per ottenere la conversione di valori
  • Un modo per consentire alle associazioni di dipendere da più di un parametro.

Annotazioni

Per usare le funzioni con {x:Bind}, la versione minima dell'SDK di destinazione dell'app deve essere 14393 o successiva. Non puoi usare le funzioni quando la tua app è destinata a versioni precedenti di Windows 10. Per ulteriori informazioni sulle versioni target, vedere Codice adattivo della versione.

Nell'esempio seguente lo sfondo e il primo piano dell'elemento sono associati alle funzioni per eseguire la conversione in base al parametro color

<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);
    }
}

Utilizzo degli attributi XAML

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

Percorso della funzione

Il percorso della funzione viene specificato come altri percorsi delle proprietà e può includere punti (.), indici o cast per individuare la funzione.

È possibile specificare funzioni statiche usando la sintassi XMLNamespace:ClassName.MethodName. Ad esempio, usare la sintassi seguente per l'associazione a funzioni statiche nel code-behind.

<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;
    }
}

È anche possibile usare le funzioni di sistema direttamente nel markup per eseguire semplici scenari come la formattazione della data, la formattazione del testo, le concatenazioni di testo e così via, ad esempio:

<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 la modalità è OneWay/TwoWay, il rilevamento delle modifiche verrà eseguito sul percorso della funzione e l'associazione verrà rivalutata se sono presenti modifiche a quegli oggetti.

La funzione cui è associata deve:

  • Essere accessibili al codice e ai metadati, quindi il lavoro interno/privato in C#, ma C++/CX dovrà usare metodi WinRT pubblici
  • Il sovraccarico si basa sul numero di argomenti, non sul tipo, e cercherà di abbinare il primo sovraccarico con quel numero di argomenti.
  • I tipi di argomento devono corrispondere ai dati passati – non eseguiamo conversioni restrittive.
  • Il tipo restituito della funzione deve corrispondere al tipo della proprietà che utilizza l'associazione

Il motore di associazione reagisce alle notifiche di modifica delle proprietà attivate con il nome della funzione e valuta nuovamente le associazioni in base alle esigenze. Per esempio:

<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
        }
    }
}

Suggerimento

È possibile usare le funzioni in x:Bind per ottenere gli stessi scenari supportati tramite Convertitori e MultiBinding in WPF.

Argomenti della funzione

È possibile specificare più argomenti di funzione, separati da virgole (,)

  • Percorso di associazione: stessa sintassi come se si stesse associando direttamente a tale oggetto.
    • Se la modalità è OneWay/TwoWay, verrà eseguito il rilevamento delle modifiche e l'associazione verrà rivalutata in caso di modifiche dell'oggetto
  • Stringa costante racchiusa tra virgolette: sono necessarie virgolette per designarla come stringa. Hat (^) può essere usato per le virgolette di escape nelle stringhe
  • Numero costante, ad esempio -123.456
  • Valore booleano: specificato come "x:Vero" o "x:Falso"

Suggerimento

TargetNullValue verrà applicato al risultato della chiamata di funzione, non ad alcun argomento associato.

Collegamenti funzionali bidirezionali

In uno scenario di associazione bidirezionale, è necessario specificare una seconda funzione per la direzione inversa dell'associazione. Questa operazione viene eseguita usando la proprietà di associazione BindBack. Nell'esempio seguente, la funzione deve accettare un argomento, ovvero il valore che deve essere restituito al modello.

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

Vedere anche

  • Estensione di markup {x:Bind}
  • Last updated on