Megosztás:

Függvények x:Kötés winUI-val

A WinUI-alkalmazások lehetővé teszik a függvények használatát a korrektúrakiterjesztés adatkötési útvonalának {x:Bind} levéllépéseként. Ez a funkció leegyszerűsíti az értékátalakítást, és lehetővé teszi, hogy a kötések több paramétertől függjenek, így az alkalmazás dinamikusabbá és hatékonyabbá válik.

Jótanács

Az adatkötés alkalmazáson belüli {x:Bind} használatával kapcsolatos általános információkért (és a {x:Bind} és {Binding}közötti teljes összehasonlításért) tekintse meg Az adatkötés mélyreható és {x:Bind} jelölőnyelvi kiterjesztés.

Az alábbi példában az elem háttere és előtere olyan függvényekhez van kötve, amelyek a színparaméter alapján konverziót végeznek.

<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-attribútumok használata

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

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

Adja meg a függvény elérési útját , mint más tulajdonságútvonalakat. Az elérési út tartalmazhat pontokat (.), indexelőket vagy leadókat a függvény megkereséséhez.

Statikus függvények megadásához használja a XMLNamespace:ClassName.MethodName szintaxist. Az alábbi szintaxis használatával például a kód mögötti statikus függvényekhez kapcsolódhat.

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

A rendszerfüggvényeket közvetlenül a korrektúrákban is használhatja olyan egyszerű forgatókönyvek végrehajtásához, mint a dátumformázás, a szövegformázás, a szövegösszefűzések stb. Például:

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

Ha a módot OneWay vagy TwoWay értékre állítja, a függvény elérési útja támogatja a változásészlelést. A kötési motor újra kiértékeli a kötést, ha ezek az objektumok megváltoznak.

A függvény, amelyhez köt, meg kell felelnie a következő követelményeknek:

  • A kódhoz és a metaadatokhoz való hozzáférés – így a belső vagy privát munkák C#-ban működnek, de a C++-nak nyilvános WinRT-metódusokra van szüksége
  • Támogatja a túlterhelést nem pedig típus alapján, hanem az argumentumok száma alapján, és megpróbálja az első túlterhelést az adott számú argumentummal egyezni.
  • Olyan argumentumtípusokkal rendelkezik, amelyek megfelelnek az átadott adatoknak – a kötési motor nem hajt végre szűkítő konverziókat
  • A kötést használó tulajdonság típusának megfelelő visszatérési típussal rendelkezik

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

Jótanács

A függvények x:Bind használatával ugyanazokat a forgatókönyveket érheti el, mint amelyek a WPF konvertereivel és MultiBinding szolgáltatásával támogatottak.

Függvényargumentumok

Adjon meg több függvényargumentumot vesszővel (,) elválasztva.

  • Kötési útvonal – Ugyanazt a szintaxist használja, mintha közvetlenül az objektumhoz kötött volna.
    • Ha a módot OneWay vagy TwoWay értékre állítja, a kötés észleli a változásokat, és újraértékeli az objektum változásait.
  • Az állandó sztringet idézőjelek közé kell zárni – Az idézőjelek használata jelzi, hogy sztringről van szó. Sztringek idézőjeleinek feloldásához használja a kalapot (^).
  • Állandó szám – Például -123,456.
  • Logikai érték – Adja meg az "x:True" vagy az "x:False" értéket.

Jótanács

A TargetNullValue függvényhívás eredményére vonatkozik, nem kötött argumentumokra.

Kétirányú függvénykötések

Kétirányú kötési forgatókönyvben meg kell adnia egy második függvényt a kötés fordított irányához. Használja a BindBack függvény kötési tulajdonságát. A következő példában a függvény egy argumentumot vesz fel, 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

  • Last updated on