Extension de balisage {x:Bind}

Remarque Pour obtenir des informations générales sur l’utilisation de la liaison de données dans votre application avec {x :Bind} (et pour une comparaison complète entre {x :Bind} et {Binding}), consultez la liaison de données en profondeur.

L’extension de balisage {x :Bind} (nouvelle pour Windows 10) est une alternative à {Binding}. {x :Bind} s’exécute en moins de temps et moins de mémoire que {Binding} et prend en charge un meilleur débogage.

Au moment de la compilation XAML, {x :Bind} est converti en code qui obtient une valeur d’une propriété sur une source de données et la définit sur la propriété spécifiée dans le balisage. L’objet de liaison peut éventuellement être configuré pour observer les modifications apportées à la valeur de la propriété de source de données et s’actualiser en fonction de ces modifications (Mode="OneWay"). Il peut également être configuré pour envoyer (push) les modifications apportées à sa propre valeur à la propriété source (Mode="TwoWay").

Les objets de liaison créés par {x:Bind} et {Binding} sont en grande partie équivalents du point de vue fonctionnel. Toutefois , {x :Bind} exécute du code à usage spécial, qu’il génère au moment de la compilation, et {Binding} utilise l’inspection d’objet runtime à usage général. Par conséquent, les liaisons {x :Bind} (souvent appelées liaisons compilées) présentent de bonnes performances, fournissent une validation au moment de la compilation de vos expressions de liaison et prennent en charge le débogage en vous permettant de définir des points d’arrêt dans les fichiers de code générés en tant que classe partielle pour votre page. Ces fichiers se trouvent dans votre dossier obj, et portent des noms tels que <view name>.g.cs (pour C#).

Exemples d’applications illustrant {x:Bind}

• Exemple {x :Bind}
• QuizGame
• Galerie de contrôles XAML

Utilisation des attributs XAML

<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}" .../>

Exemples

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

Cet exemple XAML utilise {x :Bind} avec une propriété ListView.ItemTemplate . Notez la déclaration d’une valeur x :DataType .

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

Chemin de la propriété

PropertyPath définit le chemin d’accès pour une expression {x :Bind} . Le chemin d’accès est un chemin de propriété spécifiant la valeur de la propriété, de la sous-propriété, du champ ou de la méthode à laquelle vous vous liez (la source). Vous pouvez mentionner explicitement le nom de la propriété Path : {x:Bind Path=...}. Ou vous pouvez l’omettre : {x:Bind ...}.

Résolution du chemin d’accès aux propriétés

{x :Bind} n’utilise pas DataContext comme source par défaut. Il utilise plutôt la page ou le contrôle utilisateur lui-même. Il examine donc le code-behind de votre page ou contrôle utilisateur pour les propriétés, les champs et les méthodes. Pour exposer votre modèle d’affichage à {x :Bind}, vous souhaiterez généralement ajouter de nouveaux champs ou propriétés au code-behind de votre page ou contrôle utilisateur. Les étapes d’un chemin de propriété sont délimitées par des points (.) et vous pouvez inclure plusieurs délimiteurs pour parcourir les sous-propriétés successives. Utilisez le délimiteur de points, quel que soit le langage de programmation utilisé pour implémenter l’objet lié.

Par exemple : dans une page, Text="{x :Bind Employee.FirstName} » recherche un membre Employee sur la page, puis un membre FirstName sur l’objet retourné par Employee. Si vous liez un contrôle d’éléments à une propriété qui contient les dépendants d’un employé, votre chemin de propriété peut être « Employee.Dependents », et le modèle d’élément du contrôle d’éléments s’occuperait de l’affichage des éléments dans « Dépendants ».

Pour C++/CX, {x :Bind} ne peut pas se lier à des champs privés et des propriétés dans le modèle de données ou de page. Vous devez disposer d’une propriété publique pour qu’elle soit pouvant être liée. La surface d’exposition de la liaison doit être exposée en tant que classes/interfaces CX afin que nous puissions obtenir les métadonnées pertinentes. L’attribut [Bindable] ne doit pas être nécessaire.

Avec x :Bind, vous n’avez pas besoin d’utiliser ElementName=xxx dans le cadre de l’expression de liaison. Au lieu de cela, vous pouvez utiliser le nom de l’élément comme première partie du chemin d’accès de la liaison, car les éléments nommés deviennent des champs dans la page ou le contrôle utilisateur qui représente la source de liaison racine.

Collections

Si la source de données est une collection, un chemin de propriété peut spécifier des éléments dans la collection en fonction de leur position ou de leur index. Par exemple, « Teams[0]. Joueurs », où le littéral « [] » entoure le « 0 » qui demande le premier élément d’une collection indexée zéro.

Pour utiliser un indexeur, le modèle doit implémenter IList<T> ou IVector<T> sur le type de la propriété qui va être indexée. (Notez que IReadOnlyList<T> et IVectorView<T> ne prennent pas en charge la syntaxe de l’indexeur.) Si le type de la propriété indexée prend en charge INotifyCollectionChanged ou IObservableVector et que la liaison est OneWay ou TwoWay, elle enregistre et écoute les notifications de modification sur ces interfaces. La logique de détection des modifications est mise à jour en fonction de toutes les modifications de collection, même si cela n’affecte pas la valeur indexée spécifique. Cela est dû au fait que la logique d’écoute est commune à toutes les instances de la collection.

Si la source de données est un dictionnaire ou une carte, un chemin de propriété peut spécifier des éléments dans la collection par leur nom de chaîne. Par exemple <TextBlock Text="{x :Bind Players['John Smith']} » /> recherche un élément dans le dictionnaire nommé « John Smith ». Le nom doit être placé entre guillemets, et les guillemets simples ou doubles peuvent être utilisés. Hat (^) peut être utilisé pour échapper des guillemets dans des chaînes. Il est généralement plus simple d’utiliser d’autres guillemets de ceux utilisés pour l’attribut XAML. (Notez que IReadOnlyDictionary<T> et IMapView<T> ne prennent pas en charge la syntaxe de l’indexeur.)

Pour utiliser un indexeur de chaîne, le modèle doit implémenter la chaîne IDictionary<, T> ou IMap<, T> sur le type de la propriété qui va être indexée. Si le type de la propriété indexée prend en charge IObservableMap et que la liaison est OneWay ou TwoWay, elle s’inscrit et écoute les notifications de modification sur ces interfaces. La logique de détection des modifications est mise à jour en fonction de toutes les modifications de collection, même si cela n’affecte pas la valeur indexée spécifique. Cela est dû au fait que la logique d’écoute est commune à toutes les instances de la collection.

Propriétés attachées

Pour lier des propriétés jointes, vous devez placer la classe et le nom de propriété entre parenthèses après le point. Par exemple Text="{x :Bind Button22.( Grid.Row)}". Si la propriété n’est pas déclarée dans un espace de noms Xaml, vous devez le préfixer avec un espace de noms xml, que vous devez mapper à un espace de noms de code à la tête du document.

Transtypage

Les liaisons compilées sont fortement typées et résolvent le type de chaque étape dans un chemin d’accès. Si le type retourné n’a pas le membre, il échoue au moment de la compilation. Vous pouvez spécifier un cast pour indiquer à la liaison le type réel de l’objet.

Dans le cas suivant, obj est une propriété d’objet de type, mais contient une zone de texte. Nous pouvons donc utiliser Text="{x :Bind ((TextBox)obj). Text} » ou Text="{x :Bind obj.(TextBox.Text)} ».

Champ groups3 dans Text="{x :Bind ((data :SampleDataGroup)groups3[0]). Title}" est un dictionnaire d’objets. Vous devez donc le convertir en données :SampleDataGroup. Notez l’utilisation des données xml : préfixe d’espace de noms pour mapper le type d’objet à un espace de noms de code qui ne fait pas partie de l’espace de noms XAML par défaut.

Remarque : La syntaxe de cast de style C#est plus flexible que la syntaxe de propriété jointe et est la syntaxe recommandée à l’avenir.

Cast sans chemin

L’analyseur de liaison native ne fournit pas de mot clé à représenter this en tant que paramètre de fonction, mais prend en charge le cast sans chemin (par exemple, {x:Bind (x:String)}), qui peut être utilisé comme paramètre de fonction. Par conséquent, {x:Bind MethodName((namespace:TypeOfThis))} est un moyen valide d’effectuer ce qui est conceptuellement équivalent à {x:Bind MethodName(this)}.

Exemple :

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

Fonctions dans les chemins de liaison

À compter de Windows 10, version 1607, {x : Bind} prend en charge l’utilisation d’une fonction comme niveau feuille du chemin de liaison. Il s’agit d’une fonctionnalité puissante pour la liaison de données qui permet plusieurs scénarios dans le balisage. Pour plus d’informations, consultez les liaisons de fonction.

Liaison d’événements

La liaison d’événements est une fonctionnalité unique pour la liaison compilée. Il vous permet de spécifier le gestionnaire d’un événement à l’aide d’une liaison, au lieu d’être une méthode sur le code-behind. Par exemple : Click="{x :Bind rootFrame.GoForward} ».

Pour les événements, la méthode cible ne doit pas être surchargée et doit également :

• Correspond à la signature de l’événement.
• OR n’a aucun paramètre.
• OR a le même nombre de paramètres de types qui sont assignables à partir des types des paramètres d’événement.

Dans le code-behind généré, la liaison compilée gère l’événement et l’achemine vers la méthode sur le modèle, en évaluant le chemin d’accès de l’expression de liaison lorsque l’événement se produit. Cela signifie que, contrairement aux liaisons de propriétés, il ne suit pas les modifications apportées au modèle.

Pour plus d’informations sur la syntaxe de chaîne d’un chemin de propriété, consultez la syntaxe de chemin d’accès aux propriétés, en gardant à l’esprit les différences décrites ici pour {x :Bind}.

Propriétés que vous pouvez définir avec {x :Bind}

{x :Bind} est illustré avec la syntaxe de l’espace réservé bindingProperties , car il existe plusieurs propriétés en lecture/écriture qui peuvent être définies dans l’extension de balisage. Les propriétés peuvent être définies dans n’importe quel ordre avec des paires de valeurs propName=séparées par des virgules. Notez que vous ne pouvez pas inclure de sauts de ligne dans l’expression de liaison. Certaines des propriétés nécessitent des types qui n’ont pas de conversion de type. Celles-ci nécessitent donc des extensions de balisage de leur propre imbrication dans { x :Bind}.

Ces propriétés fonctionnent de la même façon que les propriétés de la classe Binding.

Notes

Étant donné que {x :Bind} utilise du code généré pour obtenir ses avantages, il nécessite des informations de type au moment de la compilation. Cela signifie que vous ne pouvez pas lier à des propriétés où vous ne connaissez pas le type à l’avance. En raison de cela, vous ne pouvez pas utiliser {x :Bind} avec la propriété DataContext , qui est de type Object, et est également susceptible de changer au moment de l’exécution.

Lorsque vous utilisez {x :Bind} avec des modèles de données, vous devez indiquer le type auquel il est lié en définissant une valeur x :DataType , comme indiqué dans la section Exemples . Vous pouvez également définir le type sur un type d’interface ou de classe de base, puis utiliser des casts si nécessaire pour formuler une expression complète.

Les liaisons compilées dépendent de la génération de code. Par conséquent, si vous utilisez {x :Bind} dans un dictionnaire de ressources, le dictionnaire de ressources doit avoir une classe code-behind. Consultez les dictionnaires de ressources avec {x :Bind} pour obtenir un exemple de code.

Les pages et les contrôles utilisateur qui incluent des liaisons compilées ont une propriété « Bindings » dans le code généré. Celle-ci comprend les méthodes suivantes :

• Update() : cette opération met à jour les valeurs de toutes les liaisons compilées. Toutes les liaisons unidirectionnelle/bidirectionnelle auront les écouteurs branchés pour détecter les modifications.
• Initialize() : si les liaisons n’ont pas déjà été initialisées, elle appelle Update() pour initialiser les liaisons
• StopTracking() : cela désactive tous les écouteurs créés pour les liaisons unidirectionnelle et bidirectionnelle. Ils peuvent être réin initialisés à l’aide de la méthode Update().

Conseil Si vous devez spécifier une accolade unique pour une valeur, telle que Path ou ConverterParameter, précédez-la avec une barre oblique inverse : \{ Vous pouvez également placer la chaîne entière qui contient les accolades qui ont besoin d’échapper dans un ensemble de guillemets secondaires, par exemple ConverterParameter='{Mix}'.

Converter, ConverterLanguage et ConverterLanguage sont tous liés au scénario de conversion d’une valeur ou d’un type à partir de la source de liaison en un type ou une valeur compatible avec la propriété cible de liaison. Pour plus d’informations et d’exemples, consultez la section « Conversions de données » de la liaison de données en profondeur.

{x :Bind} est une extension de balisage uniquement, sans moyen de créer ou de manipuler de telles liaisons par programmation. Pour plus d’informations sur les extensions de balisage, consultez la vue d’ensemble du code XAML.