{x:Bind} markeringstillägg

Not Allmän information om hur du använder databindning i din app med {x:Bind} (och för en fullständig jämförelse mellan {x:Bind} och {Binding}) finns i Databindning på djupet.

Markeringstillägget {x:Bind} – nytt för Windows 10 – är ett alternativ till {Binding}. {x:Bind} körs på kortare tid och mindre minne än {Binding} och stöder bättre felsökning.

Vid XAML-kompileringstiden konverteras {x:Bind} till kod som hämtar ett värde från en egenskap på en datakälla och anger det på den egenskap som anges i markering. Bindningsobjektet kan eventuellt konfigureras för att observera ändringar i värdet för datakällegenskapen och uppdatera sig själv baserat på dessa ändringar (Mode="OneWay"). Du kan också konfigurera den för att skicka tillbaka ändringar i sitt eget värde till källegenskapen (Mode="TwoWay").

Bindningsobjekten som skapats av {x:Bind} och {Binding} är till stor del funktionellt likvärdiga. Men {x:Bind} kör specialkod, som genereras vid kompileringstid, och {Binding} använder allmän körningsobjektgranskning. Därför har {x:Bind} -bindningar (kallas ofta kompilerade bindningar) bra prestanda, ger kompileringstidsverifiering av dina bindningsuttryck och stöder felsökning genom att du kan ange brytpunkter i kodfilerna som genereras som partiell klass för sidan. Dessa filer finns i mappen obj med namn som (för C#) <view name>.g.cs.

XAML-attributanvändning

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

Examples

<Page x:Class="QuizGame.View.HostView" ... >
    <Button Content="{x:Bind Path=ViewModel.NextButtonText, Mode=OneWay}" ... />
</Page>

I det här exemplet använder XAML {x:Bind} med egenskapen ListView.ItemTemplate . Observera deklarationen av ett x:DataType-värde .

  <DataTemplate x:Key="SimpleItemTemplate" x:DataType="data:SampleDataGroup">
    <StackPanel Orientation="Vertical" Height="50">
      <TextBlock Text="{x:Bind Title}"/>
      <TextBlock Text="{x:Bind Description}"/>
    </StackPanel>
  </DataTemplate>

Egenskapsväg

PropertyPath anger sökvägen för ett {x:Bind}- uttryck. Sökväg är en sökväg som anger värdet för egenskapen, underegenskapen, fältet eller metoden som du binder till (källan). Du kan uttryckligen nämna namnet på egenskapen Path : {x:Bind Path=...}. Eller så kan du utelämna det: {x:Bind ...}.

Lösning för egenskapssökväg

{x:Bind} använder inte DataContext som standardkälla. I stället används själva sidan eller användarkontrollen. Så den kommer att söka i koden bakom din sida eller användarkontroll för egenskaper, fält och metoder. Om du vill exponera vymodellen för {x:Bind} vill du vanligtvis lägga till nya fält eller egenskaper i koden bakom för sidan eller användarkontrollen. Steg i en egenskapssökväg avgränsas av punkter (.), och du kan inkludera flera avgränsare för att bläddra i efterföljande underegenskaper. Använd punktavgränsaren oavsett vilket programmeringsspråk som används för att implementera objektet som är bundet till.

Till exempel: På en sida letar Text="{x:Bind Employee.FirstName}" efter en anställds medlem på sidan och sedan en FirstName-medlem i objektet som returneras av Employee. Om du binder en objektkontroll till en egenskap som innehåller en anställds beroenden kan din egenskapssökväg vara "Employee.Dependents" och objektmallen för objektkontrollen tar hand om att visa objekten i "Beroenden".

För C++/CX kan {x:Bind} inte binda till privata fält och egenskaper på sidan eller datamodellen – du måste ha en offentlig egenskap för att den ska kunna bindas. Ytan för bindning måste exponeras som CX-klasser/gränssnitt så att vi kan hämta relevanta metadata. Attributet [Bindable] bör inte behövas.

Med x:Bind behöver du inte använda ElementName=xxx som en del av bindningsuttrycket. I stället kan du använda namnet på elementet som den första delen av sökvägen för bindningen eftersom namngivna element blir fält på sidan eller användarkontrollen som representerar rotbindningskällan.

Collections

Om datakällan är en samling kan en egenskapssökväg ange objekt i samlingen efter deras position eller index. Till exempel "Teams[0].Spelare", där literalen "[]" omger "0" som begär det första objektet i en nollindexerad samling.

Om du vill använda en indexerare måste modellen implementera IList<T> eller IVector<T> på den typ av egenskap som ska indexeras. (Observera att IReadOnlyList<T> och IVectorView<T> stöder inte indexerarens syntax.) Om typen av den indexerade egenskapen stöder INotifyCollectionChanged eller IObservableVector och bindningen är OneWay eller TwoWay, registreras den och lyssnar efter ändringsmeddelanden i dessa gränssnitt. Logiken för ändringsidentifiering uppdateras baserat på alla samlingsändringar, även om det inte påverkar det specifika indexerade värdet. Det beror på att lyssningslogik är vanlig i alla instanser av samlingen.

Om datakällan är en ordlista eller karta kan en egenskapssökväg ange objekt i samlingen efter deras strängnamn. Till exempel <TextBlock Text="{x:Bind Players['John Smith']}" /> söker efter ett objekt i ordlistan med namnet "John Smith". Namnet måste omges av citattecken och antingen enkla eller dubbla citattecken kan användas. Hat (^) kan användas för att undkomma citattecken i strängar. Det är vanligtvis enklast att använda alternativa citattecken från de som används för XAML-attributet. (Observera att IReadOnlyDictionary<T> och IMapView<T> stöder inte indexerarens syntax.)

Om du vill använda en strängindexerare måste modellen implementera IDictionary-sträng<, T> - eller IMap-sträng<, T> på den typ av egenskap som ska indexeras. Om typen av den indexerade egenskapen stöder IObservableMap och om bindningen är OneWay eller TwoWay, kommer den att registreras och lyssna efter ändringsmeddelanden på dessa gränssnitt. Logiken för ändringsidentifiering uppdateras baserat på alla samlingsändringar, även om det inte påverkar det specifika indexerade värdet. Det beror på att lyssningslogik är vanlig i alla instanser av samlingen.

Anslutna egenskaper

Om du vill binda till kopplade egenskaper måste du placera klass- och egenskapsnamnet i parenteser efter punkten. Till exempel Text="{x:Bind Button22.(Grid.Row)}". Om egenskapen inte deklareras i ett Xaml-namnområde måste du prefixa den med ett XML-namnområde, som du bör mappa till ett kodnamnområde i dokumentets huvud.

Gjutning

Kompilerade bindningar är strängt typade och bestämmer typen av varje steg i en sökväg. Om den returnerade typen inte har medlemmen misslyckas den vid kompileringstillfället. Du kan ange en gjutning för att ange bindning av den verkliga typen av objekt.

I följande fall är obj en egenskap av typen objekt, men innehåller en textruta, så vi kan använda antingen Text="{x:Bind ((TextBox)obj). Text}" eller Text="{x:Bind obj.(TextBox.Text)}".

Fältet groups3 i Text="{x:Bind ((data:SampleDataGroup)groups3[0]). Title}" är en ordlista med objekt, så du måste skicka den till data:SampleDataGroup. Observera användningen av xml-data: namnområdesprefixet för att mappa objekttypen till ett kodnamnområde som inte ingår i XAML-standardnamnområdet.

Obs! Syntaxen för typomvandling i C#-stil är mer flexibel än syntaxen för kopplade egenskaper och rekommenderas för framtiden.

Sökvägslös gjutning

Den inbyggda bindningsparsern tillhandahåller inte ett nyckelord som ska representeras this som en funktionsparameter, men den stöder pathless casting (till exempel {x:Bind (x:String)}), som kan användas som en funktionsparameter. {x:Bind MethodName((namespace:TypeOfThis))} är ett giltigt sätt att utföra det som begreppsmässigt motsvarar {x:Bind MethodName(this)} därför.

Exempel:

Text="{x:Bind local:MainPage.GenerateSongTitle((local:SongItem))}"

<Page
    x:Class="AppSample.MainPage"
    ...
    xmlns:local="using:AppSample">

    <Grid>
        <ListView ItemsSource="{x:Bind Songs}">
            <ListView.ItemTemplate>
                <DataTemplate x:DataType="local:SongItem">
                    <TextBlock
                        Margin="12"
                        FontSize="40"
                        Text="{x:Bind local:MainPage.GenerateSongTitle((local:SongItem))}" />
                </DataTemplate>
            </ListView.ItemTemplate>
        </ListView>
    </Grid>
</Page>

namespace AppSample
{
    public class SongItem
    {
        public string TrackName { get; private set; }
        public string ArtistName { get; private set; }

        public SongItem(string trackName, string artistName)
        {
            ArtistName = artistName;
            TrackName = trackName;
        }
    }

    public sealed partial class MainPage : Page
    {
        public List<SongItem> Songs { get; }
        public MainPage()
        {
            Songs = new List<SongItem>()
            {
                new SongItem("Track 1", "Artist 1"),
                new SongItem("Track 2", "Artist 2"),
                new SongItem("Track 3", "Artist 3")
            };

            this.InitializeComponent();
        }

        public static string GenerateSongTitle(SongItem song)
        {
            return $"{song.TrackName} - {song.ArtistName}";
        }
    }
}

Funktioner i bindningsvägar

Från och med Windows 10 version 1607 stöder {x:Bind} användning av en funktion som lövsteg i bindningssökvägen. Det här är en kraftfull funktion för databindning som möjliggör flera scenarier i markering. Mer information finns i funktionsbindningar .

Händelsebindning

Händelsebindning är en unik funktion för kompilerad bindning. Det gör att du kan ange hanteraren för en händelse med hjälp av en bindning, i stället för att det måste vara en metod för koden bakom. Exempel: Click="{x:Bind rootFrame.GoForward}".

För händelser får målmetoden inte vara överbelastad och måste också:

• Matcha signaturen för händelsen.
• ELLER har inga parametrar.
• ELLER har samma antal parametrar av typer som kan tilldelas från typerna av händelseparametrarna.

I genererad kod-bakom hanterar kompilerad bindning händelsen och dirigerar den till metoden i modellen och bedömer bindningsuttryckets sökväg när händelsen inträffar. Det innebär att den, till skillnad från egenskapsbindningar, inte spårar ändringar i modellen.

Mer information om strängsyntaxen för en egenskapssökväg finns i Syntax för egenskapssökväg med tanke på skillnaderna som beskrivs här för {x:Bind}.

Egenskaper som du kan ange med {x:Bind}

{x:Bind} illustreras med platshållarsyntaxen bindingProperties eftersom det finns flera läs-/skrivegenskaper som kan anges i markeringstillägget. Egenskaperna kan anges i valfri ordning med kommaavgränsade propName-värdepar=. Observera att du inte kan ta med radbrytningar i bindningsuttrycket. Vissa av egenskaperna kräver typer som inte har någon typkonvertering, så dessa kräver markup-tillägg som är egna och inbäddade inom {x:Bind}.

Dessa egenskaper fungerar på ungefär samma sätt som egenskaperna för klassen Bindning .

Anmärkningar

Eftersom {x:Bind} använder genererad kod för att uppnå dess fördelar, krävs typinformation vid kompileringstillfället. Det innebär att du inte kan binda till egenskaper där du inte känner till typen i förväg. Därför kan du inte använda {x:Bind} med egenskapen DataContext , som är av typen Object, och kan också ändras vid körning.

När du använder {x:Bind} med datamallar måste du ange vilken typ som ska bindas till genom att ange ett x:DataType-värde , som du ser i avsnittet Exempel . Du kan också ange typen till ett gränssnitt eller en basklasstyp och sedan använda casts om det behövs för att formulera ett fullständigt uttryck.

Kompilerade bindningar beror på kodgenerering. Om du använder {x:Bind} i en resursordbok måste resursordboken ha en kod-bakom-klass. Se Resursordlistor med {x:Bind} för ett kodexempel.

Sidor och användarkontroller som innehåller kompilerade bindningar har egenskapen "Bindningar" i den genererade koden. Detta omfattar följande metoder:

• Update() – Detta uppdaterar värdena för alla kompilerade bindningar. Alla enkelriktade/tvåriktade bindningar kommer att ha lyssnarna kopplade för att identifiera ändringar.
• Initialize() – Om bindningarna inte redan har initierats anropas Update() för att initiera bindningarna
• StopTracking() – Detta kommer att koppla bort alla lyssnare som skapats för enkelriktade och dubbelriktade bindningar. De kan initieras på nytt med hjälp av metoden Update().

Konverteraren, ConverterLanguage och ConverterLanguage är alla relaterade till scenariot att konvertera ett värde eller en typ från bindningskällan till en typ eller ett värde som är kompatibelt med bindningsmålegenskapen. Mer information och exempel finns i avsnittet "Datakonverteringar" i Databindning på djupet.

{x:Bind} är endast ett tillägg för markering, utan något sätt att skapa eller ändra sådana bindningar programmatiskt. Mer information om tillägg för markering finns i XAML-översikt.