Funkcje w x:Bind z winUI

Aplikacje WinUI umożliwiają używanie funkcji jako końcowego etapu ścieżki powiązania danych w {x:Bind} rozszerzeniu składniowym. Ta funkcja upraszcza konwersję wartości i umożliwia powiązanie w zależności od wielu parametrów, dzięki czemu aplikacja jest bardziej dynamiczna i wydajna.

W poniższym przykładzie tło i pierwszy plan elementu są powiązane z funkcjami, które wykonują konwersję na podstawie parametru koloru.

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

Użycie atrybutu XAML

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

Ścieżka do funkcji

Określ ścieżkę do funkcji , podobnie jak inne ścieżki właściwości. Ścieżka może zawierać kropki (.), indeksatory lub rzutowania w celu zlokalizowania funkcji.

XMLNamespace:ClassName.MethodName Użyj składni, aby określić funkcje statyczne. Na przykład użyj następującej składni, aby powiązać funkcje statyczne w pliku 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;
    }
}

Funkcje systemowe można również używać bezpośrednio w znacznikach, aby wykonać proste scenariusze, takie jak formatowanie dat, formatowanie tekstu, łączenie tekstu i nie tylko. Przykład:

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

Jeśli ustawisz tryb na OneWay lub TwoWay, ścieżka funkcji obsługuje wykrywanie zmian. Aparat powiązań ponownie oblicza powiązanie, jeśli te obiekty się zmienią.

Funkcja, z którą jest wiązana, musi:

• Można uzyskać dostęp do kodu i metadanych – tak więc wewnętrzne (internal) lub prywatne (private) działa w języku C#, ale metody WinRT muszą być publiczne w C++.
• Obsługa przeciążenia na podstawie liczby argumentów, a nie typu, i próbuje dopasować pierwsze przeciążenie z odpowiednią liczbą argumentów.
• Mają typy argumentów pasujące do przekazywanych danych — aparat powiązania nie wykonuje konwersji zawężających
• Mieć typ zwracany, który jest zgodny z typem właściwości używającej powiązania

Aparat powiązania reaguje na powiadomienia o zmianie właściwości wyzwalane za pomocą nazwy funkcji i w razie potrzeby ponownie ocenia powiązania. Przykład:

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

Argumenty funkcji

Określ wiele argumentów funkcji rozdzielonych przecinkami (,).

• Ścieżka powiązania — użyj tej samej składni, co w przypadku powiązania bezpośrednio z tym obiektem.
  • Jeśli ustawisz tryb na OneWay lub TwoWay, powiązanie wykryje zmiany i dokona ponownej oceny po zmianie obiektu.
• Ciąg tekstowy ujęty w cudzysłowy — dołącz cudzysłowy, aby wyznaczyć ją jako ciąg. Użyj kapelusza (^), aby uniknąć cudzysłowów w ciągach.
• Liczba stała — na przykład -123.456.
• Wartość Boolean — określ jako "x:True" lub "x:False".

Powiązania funkcji dwukierunkowych

W scenariuszu powiązania dwukierunkowego należy określić drugą funkcję dla odwrotnego kierunku powiązania. BindBack Użyj właściwości powiązania dla tej funkcji. W poniższym przykładzie funkcja przyjmuje jeden argument, który jest wartością, która musi zostać wypchnięta z powrotem do modelu.

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

Zobacz także

• rozszerzenie znaczników {x:Bind}