FrameworkElement.DataContext Propriété

  • Référence

Définition

Espace de noms:
Windows.UI.Xaml
Modifier

Obtient ou définit le contexte de données d’un FrameworkElement. Une utilisation courante d’un contexte de données est lorsqu’un FrameworkElement utilise l’extension de balisage {Binding} et participe à la liaison de données.

public:
 property Platform::Object ^ DataContext { Platform::Object ^ get(); void set(Platform::Object ^ value); };
IInspectable DataContext();

void DataContext(IInspectable value);
public object DataContext { get; set; }
var object = frameworkElement.dataContext;
frameworkElement.dataContext = object;
Public Property DataContext As Object
<frameworkElement DataContext="binding"/>
- or -
<frameworkElement DataContext="{StaticResource keyedObject}"/>

Valeur de propriété

Object

Platform::Object

IInspectable

Objet à utiliser comme contexte de données.

Exemples

Cet exemple montre comment définir le DataContext directement sur un instance d’une classe personnalisée.

Si vous utilisez C++/WinRT et l’extension de balisage {Binding} , vous utiliserez la propriété FrameworkElement::D ataContext et bindableAttribute. Si vous utilisez l’extension de balisage {x:Bind} , vous n’utiliserez pas FrameworkElement::D ataContext ni BindableAttribute.

Pour plus d’informations sur l’exemple de code C++/WinRT ci-dessous (par exemple, comment utiliser la .idl liste des fichiers et que faire avec les fichiers d’implémentation qu’il génère pour vous), consultez Contrôles XAML ; liaison à une propriété C++/WinRT.

// MyColors.idl
namespace MyColorsApp
{
    [bindable]
    [default_interface]
    runtimeclass MyColors : Windows.UI.Xaml.Data.INotifyPropertyChanged
    {
        MyColors();
        Windows.UI.Xaml.Media.SolidColorBrush Brush1;
    }
}

// MyColors.h
#pragma once
#include "MyColors.g.h"
namespace winrt::MyColorsApp::implementation
{
    struct MyColors : MyColorsT<MyColors>
    {
        MyColors() = default;

        Windows::UI::Xaml::Media::SolidColorBrush Brush1();
        void Brush1(Windows::UI::Xaml::Media::SolidColorBrush const& value);
        winrt::event_token PropertyChanged(Windows::UI::Xaml::Data::PropertyChangedEventHandler const& handler);
        void PropertyChanged(winrt::event_token const& token) noexcept;

    private:
        Windows::UI::Xaml::Media::SolidColorBrush m_brush1{ nullptr };
        winrt::event<Windows::UI::Xaml::Data::PropertyChangedEventHandler> m_propertyChanged;
    };
}

namespace winrt::MyColorsApp::factory_implementation
{
    struct MyColors : MyColorsT<MyColors, implementation::MyColors>
    {
    };
}

// MyColors.cpp
#include "pch.h"
#include "MyColors.h"

namespace winrt::MyColorsApp::implementation
{
    Windows::UI::Xaml::Media::SolidColorBrush MyColors::Brush1()
    {
        return m_brush1;
    }

    void MyColors::Brush1(Windows::UI::Xaml::Media::SolidColorBrush const& value)
    {
        if (m_brush1 != value)
        {
            m_brush1 = value;
            m_propertyChanged(*this, Windows::UI::Xaml::Data::PropertyChangedEventArgs{ L"Brush1" });
        }
    }

    winrt::event_token MyColors::PropertyChanged(Windows::UI::Xaml::Data::PropertyChangedEventHandler const& handler)
    {
        return m_propertyChanged.add(handler);
    }

    void MyColors::PropertyChanged(winrt::event_token const& token) noexcept
    {
        m_propertyChanged.remove(token);
    }
}

<!-- MainPage.xaml-->
...
<TextBox x:Name="MyTextBox" Background="{Binding Brush1}"/>
...

// MainPage.h
...
#include "MyColors.h"
#include "MainPage.g.h"
...

// MainPage.cpp
#include "pch.h"
#include "MainPage.h"

using namespace winrt;
using namespace Windows::UI;
using namespace Windows::UI::Xaml;
using namespace Windows::UI::Xaml::Media;

namespace winrt::MyColorsApp::implementation
{
    MainPage::MainPage()
    {
        InitializeComponent();

        // Create an instance of the MyColors class
        // which implements INotifyPropertyChanged.
        winrt::MyColorsApp::MyColors textcolor{ winrt::make<winrt::MyColorsApp::implementation::MyColors>() };

        // Set the Brush1 property value to a new SolidColorBrush
        // with the color Red.
        textcolor.Brush1(SolidColorBrush(Colors::Red()));

        // Set the DataContext of the TextBox named MyTextBox.
        MyTextBox().DataContext(textcolor);
    }
...
}

// Create an instance of the MyColors class 
// that implements INotifyPropertyChanged.
MyColors textcolor = new MyColors();

// Brush1 is set to be a SolidColorBrush with the value Red.
textcolor.Brush1 = new SolidColorBrush(Colors.Red);

// Set the DataContext of the TextBox MyTextBox.
MyTextBox.DataContext = textcolor;

' Create an instance of the MyColors class 
' that implements INotifyPropertyChanged. 
Dim textcolor As New MyColors()

' Brush1 is set to be a SolidColorBrush with the value Red. 
textcolor.Brush1 = New SolidColorBrush(Colors.Red)

' Set the DataContext of the TextBox MyTextBox. 
MyTextBox.DataContext = textcolor

Remarques

Le contexte de données est un concept dans lequel les objets peuvent hériter des informations de liaison de données d’objets parents successifs dans une hiérarchie de relation d’objet.

L’aspect le plus important du contexte de données est la source de données utilisée pour la liaison de données. Une utilisation classique de DataContext consiste à le définir directement sur un objet de source de données. Cette source de données peut être une instance d’une classe telle qu’un objet métier. Vous pouvez également créer une source de données en tant que collection observable, afin que le contexte de données permette de détecter les modifications dans la collection de stockage. Si la source de données est définie par une bibliothèque qui est également incluse dans le projet, la définition d’un DataContext est souvent associée à l’instanciation de la source de données en tant que ressource à clé dans un ResourceDictionary, puis à la définition du DataContext en XAML avec une référence d’extension de balisage {StaticResource} .

Une autre technique de définition de DataContext consiste à l’ajouter à la racine de l’arborescence d’objets runtime, dans le cadre de la logique d’initialisation d’application, juste après avoir appelé InitializeComponent. Cette technique est présentée dans Vue d’ensemble de la liaison de données.

En plus de spécifier la source, un contexte de données peut également stocker des caractéristiques supplémentaires d’une déclaration de liaison, telles qu’un chemin d’accès dans la source de données.

La définition d’un DataContext est pratique pour définir plusieurs liaisons de propriétés différentes sur le même objet dans un contexte de données partagé. Toutefois, il est valide qu’un DataContext ne soit pas défini et que toutes les qualifications de liaison nécessaires existent dans des instructions de liaison distinctes.

La façon dont vous implémentez la source de données d’objet varie en fonction de vos besoins et de votre langage de programmation. Pour plus d’informations, voir Présentation détaillée de la liaison de données.

Un scénario courant pour les contextes de données C# et Microsoft Visual Basic consiste à utiliser un objet métier défini par le CLR qui prend en charge la notification de modification. Pour un objet métier, la classe personnalisée utilisée comme contexte de données implémente généralement INotifyPropertyChanged, afin que les mises à jour des données puissent mettre à jour une liaison unidirectionnelle ou bidirectionnelle. Si la source de données est une collection d’objets métier, elle peut implémenter INotifyCollectionChanged et la prise en charge des listes (IList ou List), ou dériver d’ObservableCollection.

S’applique à

Voir aussi