Funktioner i x:Bind med WinUI

I WinUI-appar stöder {x:Bind} användning av en funktion som lövsteg för bindningssökvägen. Detta aktiverar:

• Ett enklare sätt att uppnå värdekonvertering
• Ett sätt för bindningar att vara beroende av mer än en parameter

I följande exempel är objektets bakgrund och förgrund bundna till funktioner för konvertering baserat på färgparametern

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

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

XAML-attributanvändning

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

Sökväg till funktionen

Den sökvägen till funktionen anges som andra egenskapssökvägar och kan innehålla punkter (.), indexerare eller casts för att hitta funktionen.

Statiska funktioner kan anges med hjälp av XMLNamespace:ClassName.MethodName syntax. Använd till exempel syntaxen nedan för bindning till statiska funktioner i code-behind.

<Window 
     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>
</Window>

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

Du kan också använda systemfunktioner direkt i markering för att utföra enkla scenarier som datumformatering, textformatering, textsammanfogningar osv. Till exempel:

<Window 
     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)}" />
</Window>

Om läget är OneWay/TwoWay utförs ändringsidentifiering på funktionssökvägen och bindningen utvärderas igen om det finns ändringar i objekten.

Funktionen som den kopplas till behöver:

• Vara tillgänglig för koden och metadata – så internt/privat arbete i C#, men C++ behöver metoder för att vara offentliga WinRT-metoder
• Överlagring baseras på antalet argument, inte typ, och det kommer att försöka matcha den första överlagringen med så många argument
• Argumenttyperna måste matcha de data som skickas in – vi gör inte begränsade konverteringar
• Returtypen för funktionen måste matcha typen av egenskap som använder bindningen

Bindningsmotorn reagerar på meddelanden om egenskapsändring som utlöses med funktionsnamnet och utvärderar bindningar om det behövs. Till exempel:

<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)
    {
        var foo = new Uri(...);        
        if (isCancelled)
        {
            foo = cancellationToken;
        }
        else 
        {
            if (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 fullName; }
        set
        {
            fullName = value;
            OnPropertyChanged();
            OnPropertyChanged("IconToBitmap"); 
            //this ensures Image.Source binding re-evaluates when FullName changes in addition to Icon and CancellationToken
        }
    }
}

Funktionsargument

Flera funktionsargument kan anges, avgränsade med kommatecken (,)

• Bindningsväg – med samma syntax som om du binder direkt till objektet.
  • Om läget är OneWay/TwoWay utförs ändringsdetektion och bindningen utvärderas på nytt när objektet ändras.
• Konstant sträng omgiven med citattecken – citattecken behövs för att ange den som en sträng. Hat (^) kan användas för att undkomma citattecken i strängar
• Konstant tal – till exempel -123.456
• Booleskt värde – anges som "x:True" eller "x:False"

Tvåvägsfunktionsbindningar

I ett tvåvägsbindningsscenario måste en andra funktion anges för bindningens omvända riktning. Detta görs genom bindningsegenskapen BindBack. I exemplet nedan bör funktionen ta ett argument som är det värde som måste skickas tillbaka till modellen.

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

Se även

• {x:Bind} Markeringstillägg