FrameworkElement.DataContext Propriété

Définition

Espace de noms:
Microsoft.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 utilisateur 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 directement l’instance DataContext d’une classe personnalisée.

Si vous utilisez C++/WinRT et l’extension de balisage {Binding} , vous allez utiliser la FrameworkElement::DataContext propriété et bindableAttribute. Si vous utilisez l’extension de balisage {x :Bind} , vous n’utiliserez FrameworkElement::DataContext pas ni le BindableAttributefichier .

Pour plus d’informations sur l’exemple de code C++/WinRT ci-dessous (par exemple, comment utiliser la .idl liste des fichiers et ce qu’il faut faire avec les fichiers d’implémentation générés pour vous), consultez les 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;

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 parent successifs dans une hiérarchie de relations d’objets.

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 DataContext classique consiste à la 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 active la détection des 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’une DataContext source de données est souvent combinée à l’instanciation de la source de données en tant que ressource clé dans un ResourceDictionary, puis à la définition du DataContext code XAML avec une référence d’extension de balisage {StaticResource} .

Une autre technique de définition DataContext consiste à l’ajouter à la racine de l’arborescence d’objets runtime, dans le cadre de la logique d’initialisation de l’application, juste après l’appel InitializeComponent. Cette technique est illustrée dans la 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 à la source de données.

La définition d’un DataContext paramètre est pratique pour définir plusieurs liaisons de propriétés différentes sur le même objet sur un contexte de données partagé. Toutefois, il est valide pour qu’il 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# consiste à utiliser un objet métier défini par 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 la prise en charge de liste INotifyCollectionChanged plus (IList<T> ou List<T) ou dériver de ObservableCollection><T>.

S’applique à

Voir aussi