Függvények x:Bind-ben

A Windows 10 1607-es verziójától kezdve {x:Bind} támogatja a függvény használatát a kötési útvonal levéllépéseként. Ez a következőket teszi lehetővé:

• Az értékátalakítás egyszerűbb módja
• Egy módszer arra, hogy a kötések egynél több paramétertől függjenek

Az alábbi példában az elem háttere és előtere függvényekhez van kötve a színparaméter alapján történő átalakításhoz

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

XAML-attribútumok használata

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

A függvény elérési útja

A függvény elérési útja a többi tulajdonságútvonalhoz hasonlóan van megadva, és tartalmazhat pontokat (.), indexelőket vagy a függvény megkereséséhez.

A statikus függvények az XMLNamespace:ClassName.MethodName szintaxissal adhatók meg. Használja például az alábbi szintaxist a statikus függvényekhez való kötéshez a kód mögötti kódban.

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

A rendszerfüggvényeket közvetlenül jelölőnyelvben is használhatja egyszerű forgatókönyvek megvalósításához, mint például a dátumformázás, szövegformázás, szövegösszefűzés stb., például:

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

Ha a mód OneWay/TwoWay, akkor a függvény útvonalán változásészlelés lesz végrehajtva, és a kötés újra kiértékelésre kerül, ha ezek az objektumok módosulnak.

A kötött függvénynek a következőkre van szüksége:

• Legyen elérhető a kód és a metaadatok számára – ily módon a belső / privát munka C#-ban történik, de a C++/CX esetében a metódusoknak nyilvános WinRT-metódusoknak kell lenniük.
• A túlterhelés az argumentumok számán alapul, nem a típuson, és megpróbál megegyezni az első túlterheléssel ennyi argumentummal
• Az argumentumtípusoknak meg kell egyezniük az átadott adatokkal – nem hajtunk végre szűkítő konverziókat
• A függvény visszatérési típusának meg kell egyeznie a kötést használó tulajdonság típusával

A kötési motor reagál a függvény nevével aktivált tulajdonságváltozási értesítésekre, és szükség szerint újra kiértékeli a kötéseket. Például:

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

Függvényargumentumok

Több függvényargumentum is megadható, vesszővel elválasztva (,)

• Kötési útvonal – Ugyanaz a szintaxis, mintha közvetlenül az objektumhoz kötött volna.
  • Ha a mód OneWay/TwoWay, akkor a rendszer elvégzi a változásészlelést, és újra kiértékeli a kötést az objektumváltozások után
• Idézőjelek közé zárt állandó karaktersorozat – idézőjelek szükségesek annak megjelölésére, hogy karaktersorozatról van szó. A hat (^) sztringekben lévő idézőjelek feloldására használható
• Állandó szám – például -123.456
• Logikai érték – "x:True" vagy "x:False" formában van megadva.

Kétirányú függvénykapcsolatok

Kétirányú kötés esetén egy második függvényt kell megadni a kötés fordított irányához. Ez a BindBack kötési tulajdonsággal történik. Az alábbi példában a függvénynek egy argumentumot kell használnia, amely az az érték, amelyet vissza kell küldeni a modellbe.

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

Lásd még

• {x:Bind} jelölőkiterjesztés