{x:Bind}-Markuperweiterung

Anmerkung Allgemeine Informationen zur Verwendung der Datenbindung in Ihrer App mit {x:Bind} (und für einen Gesamtvergleich zwischen {x:Bind} und {Binding}) finden Sie unter Datenbindung im Detail.

Die {x:Bind} -Markuperweiterung – neu für Windows 10 – ist eine Alternative zu {Binding}. {x:Bind} wird in kürzerer Zeit und weniger Arbeitsspeicher als {Binding} ausgeführt und unterstützt ein besseres Debuggen.

Während der XAML-Kompilierung wird {x:Bind} in Code umgewandelt, der einen Wert aus einer Eigenschaft einer Datenquelle abruft und ihn auf die im Markup angegebene Eigenschaft setzt. Das Bindungsobjekt kann optional konfiguriert werden, um Änderungen am Wert der Datenquelleneigenschaft zu beobachten und sich basierend auf diesen Änderungen zu aktualisieren (Mode="OneWay"). Sie kann optional auch so konfiguriert werden, dass Änderungen in ihrem eigenen Wert zurück an die Quelleigenschaft (Mode="TwoWay") verschoben werden.

Die von {x:Bind} und {Binding} erstellten Bindungsobjekte sind weitgehend funktional gleichwertig. { x:Bind} führt jedoch speziellen Code aus, der zur Kompilierungszeit generiert wird, und {Binding} verwendet eine allgemeine Laufzeitobjektüberprüfung. Daher bieten {x:Bind} -Bindungen (häufig als kompilierte Bindungen bezeichnet) eine hervorragende Leistung, stellen eine Kompilierungszeitüberprüfung Ihrer Bindungsausdrücke bereit und unterstützen das Debuggen, indem Sie Haltepunkte in den Codedateien festlegen können, die als Teilklasse für Ihre Seite generiert werden. Diese Dateien finden Sie in Ihrem obj Ordner mit Namen wie (für C#). <view name>.g.cs

XAML-Attributverwendung

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

In diesem Beispiel-XAML wird {x:Bind} mit einer ListView.ItemTemplate-Eigenschaft verwendet. Beachten Sie die Deklaration eines x:DataType-Werts .

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

Eigenschaftspfad

PropertyPath legt den Pfad für einen {x:Bind} -Ausdruck fest. Path ist ein Eigenschaftspfad, der den Wert der Eigenschaft, der Untereigenschaft, des Felds oder der Methode angibt, an die Sie binden (die Quelle). Sie können den Namen der Path-Eigenschaft explizit erwähnen: {x:Bind Path=...}. Oder Sie können es weglassen: {x:Bind ...}.

Auflösung des Eigenschaftspfads

{x:Bind} verwendet dataContext nicht als Standardquelle, sondern verwendet die Seite oder das Benutzersteuerelement selbst. Daher wird im Code-behind Ihrer Seite oder Ihres Benutzersteuerelements nach Eigenschaften, Feldern und Methoden gesucht. Um Ihr Ansichtsmodell für {x:Bind} bereitzustellen, möchten Sie in der Regel dem Code-Behind für Ihre Seite oder das Benutzersteuerelement neue Felder oder Eigenschaften hinzufügen. Schritte in einem Eigenschaftspfad werden durch Punkte (.) getrennt, und Sie können mehrere Trennzeichen einschließen, um aufeinander folgende Untereigenschaften zu durchlaufen. Verwenden Sie das Punkttrennzeichen unabhängig von der Programmiersprache, an die das Objekt gebunden wird.

Beispiel: In einer Seite sucht Text="{x:Bind Employee.FirstName}" nach einem Mitarbeitermitglied auf der Seite und dann nach einem FirstName-Element für das von Employee zurückgegebene Objekt. Wenn Sie ein Elementsteuerelement an eine Eigenschaft binden, die die Abhängigen eines Mitarbeiters enthält, lautet ihr Eigenschaftspfad möglicherweise "Employee.Dependents", und die Elementvorlage des Elementsteuerelements übernimmt die Anzeige der Elemente in "Abhängige".

Für C++/CX kann {x:Bind} keine Bindung an private Felder und Eigenschaften auf der Seite oder im Datenmodell herstellen . Sie müssen über eine öffentliche Eigenschaft verfügen, damit sie gebunden werden kann. Der Oberflächenbereich für die Bindung muss als CX-Klassen/Schnittstellen verfügbar gemacht werden, damit wir die relevanten Metadaten abrufen können. Das [Bindable] -Attribut sollte nicht benötigt werden.

Bei "x:Bind" müssen Sie " ElementName=xxx " nicht als Teil des Bindungsausdrucks verwenden. Stattdessen können Sie den Namen des Elements als ersten Teil des Pfads für die Bindung verwenden, da benannte Elemente zu Feldern innerhalb der Seite oder des Benutzersteuerelements werden, die die Stammbindungsquelle darstellt.

Auflistungen

Wenn es sich bei der Datenquelle um eine Auflistung handelt, kann ein Eigenschaftspfad Elemente in der Auflistung anhand ihrer Position oder ihres Indexes angeben. Beispiel: "Teams[0].Spieler", wobei das Literal "[]" die "0" einschließt, die das erste Element in einer nullbasierten Sammlung anfordert.

Um einen Indexer zu verwenden, muss das Modell IList<T> oder IVector<T> für den Typ der Eigenschaft implementieren, die indiziert werden soll. (Beachten Sie, dass IReadOnlyList<T> und IVectorView<T> unterstützen die Indexersyntax nicht.) Wenn der Typ der indizierten Eigenschaft INotifyCollectionChanged oder IObservableVector unterstützt und die Bindung OneWay oder TwoWay ist, registriert und lauscht auf Änderungsbenachrichtigungen für diese Schnittstellen. Die Änderungserkennungslogik wird basierend auf allen Sammlungsänderungen aktualisiert, auch wenn sich dies nicht auf den spezifischen indizierten Wert auswirkt. Dies liegt daran, dass die Abhörlogik allen Instanzen der Auflistung gemeinsam ist.

Wenn es sich bei der Datenquelle um ein Wörterbuch oder eine Zuordnung handelt, kann ein Eigenschaftspfad Elemente in der Auflistung anhand ihres Zeichenfolgennamens angeben. Beispiel <: TextBlock Text="{x:Bind Players['John Smith']}" /> sucht nach einem Element im Wörterbuch namens "John Smith". Der Name muss in Anführungszeichen eingeschlossen werden, und es können einfache oder doppelte Anführungszeichen verwendet werden. Hat (^) kann verwendet werden, um Anführungszeichen in Zeichenfolgen zu maskieren. Es ist in der Regel am einfachsten, alternative Anführungszeichen von denen zu verwenden, die für das XAML-Attribut verwendet werden. (Beachten Sie, dass IReadOnlyDictionary<T> und IMapView<T> unterstützen die Indexersyntax nicht.)

Um einen Zeichenfolgenindexer zu verwenden, muss das Modell IDictionary-Zeichenfolge<, T> oder IMap-Zeichenfolge<implementieren, T> für den Typ der Eigenschaft, die indiziert werden soll. Wenn der Typ der indizierten Eigenschaft IObservableMap unterstützt und die Bindung OneWay oder TwoWay ist, registriert und lauscht er auf Änderungsbenachrichtigungen für diese Schnittstellen. Die Änderungserkennungslogik wird basierend auf allen Sammlungsänderungen aktualisiert, auch wenn sich dies nicht auf den spezifischen indizierten Wert auswirkt. Dies liegt daran, dass die Abhörlogik allen Instanzen der Auflistung gemeinsam ist.

Angefügte Eigenschaften

Um eine Bindung an angefügte Eigenschaften zu erstellen, müssen Sie den Klassen- und Eigenschaftennamen nach dem Punkt in Klammern setzen. Beispiel : Text="{x:Bind Button22.( Grid.Row)}". Wenn die Eigenschaft nicht in einem Xaml-Namespace deklariert ist, müssen Sie der Eigenschaft einen XML-Namespace voranstellen, den Sie einem Codenamespace am Anfang des Dokuments zuordnen sollten.

Guss

Kompilierte Bindungen sind stark typisiert und bestimmen den Typ jedes Schritts in einem Pfad. Wenn der zurückgegebene Typ nicht über das Mitglied verfügt, schlägt der Vorgang beim Kompilieren fehl. Sie können eine Umwandlung angeben, um die Bindung des tatsächlichen Typs des Objekts mitzuteilen.

Im folgenden Fall ist obj eine Eigenschaft vom Typ Objekt, enthält aber ein Textfeld, sodass wir entweder Text="{x:Bind ((TextBox)obj).Text}" oder Text="{x:Bind obj.(TextBox.Text)}" verwenden können.

Das Feld "groups3 " in Text="{x:Bind ((data:SampleDataGroup)groups3[0]). Title}" ist ein Wörterbuch von Objekten, daher müssen Sie es in "data:SampleDataGroup" umwandeln. Beachten Sie die Verwendung der XML-Daten: Namespacepräfix zum Zuordnen des Objekttyps zu einem Codenamespace, der nicht Teil des standardmäßigen XAML-Namespace ist.

Hinweis: Die C#-Format-Umwandlungssyntax ist flexibler als die Syntax der angefügten Eigenschaft und wird in Zukunft empfohlen.

Pfadlose Umwandlung

Der systemeigene Bindungsparser stellt kein Schlüsselwort bereit, um this als Funktionsparameter darzustellen, unterstützt jedoch pfadlose Umwandlungen (z. B. {x:Bind (x:String)}), die als Funktionsparameter verwendet werden können. Daher ist {x:Bind MethodName((namespace:TypeOfThis))} eine gültige Möglichkeit, das konzeptuelle Äquivalent zu {x:Bind MethodName(this)} durchzuführen.

Beispiel:

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

Funktionen in Bindungspfaden

Ab Windows 10, Version 1607, unterstützt {x:Bind} die Verwendung einer Funktion als Blattschritt des Bindungspfads. Dies ist ein leistungsfähiges Feature für die Datenbindung, das mehrere Szenarien im Markup ermöglicht. Details finden Sie unter Funktionsbindungen .

Ereignisbindung

Ereignisbindung ist ein eindeutiges Feature für kompilierte Bindung. Sie können den Handler für ein Ereignis mithilfe einer Bindung angeben, anstatt dass es eine Methode im Code-Behind sein muss. Beispiel: Click="{x:Bind rootFrame.GoForward}".

Für Ereignisse darf die Zielmethode nicht überladen werden und muss auch:

• Die Signatur des Ereignisses abgleichen.
• OR hat keine Parameter.
• ODER haben dieselbe Anzahl von Parametern von Typen, die aus den Typen der Ereignisparameter zugewiesen werden können.

Im generierten CodeBehind verarbeitet die kompilierte Bindung das Ereignis und leitet es an die Methode im Modell weiter und wertet den Pfad des Bindungsausdrucks aus, wenn das Ereignis auftritt. Dies bedeutet, dass im Gegensatz zu Eigenschaftenbindungen keine Änderungen am Modell nachverfolgt werden.

Weitere Informationen zur Zeichenfolgensyntax für einen Eigenschaftspfad finden Sie unter Eigenschaftspfadsyntax, wobei Sie die hier beschriebenen Unterschiede für {x:Bind} berücksichtigen.

Eigenschaften, die Sie mit {x:Bind} festlegen können

{x:Bind} wird mit der BindingProperties-Platzhaltersyntax veranschaulicht, da mehrere Lese-/Schreibeigenschaften vorhanden sind, die in der Markuperweiterung festgelegt werden können. Die Eigenschaften können in beliebiger Reihenfolge mit kommagetrennten PropName-Wertpaaren= festgelegt werden. Beachten Sie, dass Sie keine Zeilenumbrüche in den Bindungsausdruck einschließen können. Einige der Eigenschaften erfordern Typen, die keine Typkonvertierung aufweisen. Daher erfordern diese Markuperweiterungen eigene geschachtelte Markuperweiterungen innerhalb von {x:Bind}.

Diese Eigenschaften funktionieren ähnlich wie die Eigenschaften der Binding-Klasse .

Bemerkungen

Da {x:Bind} generierten Code verwendet, um seine Vorteile zu erzielen, sind zur Kompilierung Typinformationen erforderlich. Dies bedeutet, dass Sie keine Bindung an Eigenschaften vornehmen können, bei denen Sie den Typ nicht vorab kennen. Aus diesem Grund können Sie {x:Bind} nicht mit der DataContext-Eigenschaft verwenden, die vom Typ "Object" ist und zur Laufzeit ebenfalls geändert werden kann.

Wenn Sie {x:Bind} mit Datenvorlagen verwenden, müssen Sie angeben, an den der Typ gebunden wird, indem Sie einen x:DataType-Wert festlegen, wie im Abschnitt "Beispiele" gezeigt. Sie können den Typ auch auf eine Schnittstelle oder einen Basisklassentyp festlegen und dann bei Bedarf Umwandlungen verwenden, um einen vollständigen Ausdruck zu formulieren.

Kompilierte Bindungen hängen von der Codegenerierung ab. Wenn Sie also {x:Bind} in einem Ressourcenwörterbuch verwenden, muss das Ressourcenwörterbuch über eine CodeBehind-Klasse verfügen. Ein Beispielcode finden Sie unter Ressourcenwörterbüchern mit {x:Bind}.

Seiten und Benutzersteuerelemente, die kompilierte Bindungen enthalten, weisen eine "Bindings"-Eigenschaft im generierten Code auf. Dazu gehören die folgenden Methoden:

• Update() – Dadurch werden die Werte aller kompilierten Bindungen aktualisiert. Alle unidirektionalen/zweiwegigen Bindungen haben die Listener verbunden, um Änderungen zu erkennen.
• Initialize() – Wenn die Bindungen noch nicht initialisiert wurden, wird Update() aufgerufen, um die Bindungen zu initialisieren.
• StopTracking() – Dadurch werden alle Listener, die für unidirektionale und bidirektionale Bindungen erstellt wurden, entfernt. Sie können mithilfe der Update()-Methode neu initialisiert werden.

Converter, ConverterLanguage und ConverterLanguage beziehen sich alle auf das Szenario der Konvertierung eines Werts oder Typs aus der Bindungsquelle in einen Typ oder Wert, der mit der Bindungszieleigenschaft kompatibel ist. Weitere Informationen und Beispiele finden Sie im Abschnitt "Datenkonvertierungen" der Datenbindung im Detail.

{x:Bind} ist nur eine Markuperweiterung, ohne diese Bindungen programmgesteuert zu erstellen oder zu bearbeiten. Weitere Informationen zu Markuperweiterungen finden Sie in der XAML-Übersicht.