FrameworkElement.DataContext Eigenschaft

  • Referenz

Definition

Namespace:
Microsoft.UI.Xaml
Bearbeiten

Ruft den Datenkontext für ein FrameworkElement ab oder legt diese fest. Ein Datenkontext wird häufig verwendet, wenn die FrameworkElement{Binding}- Markuperweiterung verwendet wird und an der Datenbindung beteiligt ist.

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

Eigenschaftswert

Object

Platform::Object

IInspectable

Das Objekt, das als Datenkontext verwendet werden soll.

Beispiele

In diesem Beispiel wird direkt DataContext auf eine instance einer benutzerdefinierten Klasse festgelegt.

Wenn Sie C++/WinRT und die {Binding}- Markuperweiterung verwenden, verwenden Sie die FrameworkElement::DataContext -Eigenschaft und das BindableAttribute. Wenn Sie die {x:Bind}-Markuperweiterung verwenden, verwenden FrameworkElement::DataContext Sie weder .BindableAttribute

Weitere Hintergrundinformationen zum folgenden C++/WinRT-Codebeispiel (z. B. verwendung der .idl Dateiauflistung und Vorgehensweise mit den Implementierungsdateien, die für Sie generiert werden), finden Sie unter XAML-Steuerelemente; Binden an eine C++/WinRT-Eigenschaft.

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

Hinweise

Der Datenkontext ist ein Konzept, bei dem Objekte Datenbindungsinformationen von aufeinander folgenden übergeordneten Objekten in einer Objektbeziehungshierarchie erben können.

Der wichtigste Aspekt des Datenkontexts ist die Datenquelle, die für die Datenbindung verwendet wird. Eine typische Verwendung von DataContext besteht darin, es direkt auf ein Datenquellenobjekt festzulegen. Diese Datenquelle kann eine instance einer Klasse sein, z. B. ein Geschäftsobjekt. Alternativ können Sie eine Datenquelle als beobachtbare Sammlung erstellen, sodass der Datenkontext das Erkennen von Änderungen in der Sicherungssammlung ermöglicht. Wenn die Datenquelle durch eine Bibliothek definiert wird, die ebenfalls im Projekt enthalten ist, wird das Festlegen von DataContext häufig mit dem Instanziieren der Datenquelle als schlüsselierte Ressource in einem ResourceDictionary kombiniert und dann in XAML mit einem {StaticResource}-Markuperweiterungsverweis festgelegtDataContext.

Eine weitere Methode zum Festlegen DataContext ist das Hinzufügen zum Stamm der Laufzeitobjektstruktur als Teil der App-Initialisierungslogik, direkt nach dem Aufrufen InitializeComponentvon . Dieses Verfahren wird unter Übersicht über die Datenbindung veranschaulicht.

Zusätzlich zur Angabe der Quelle kann ein Datenkontext auch weitere Merkmale einer Bindungsdeklaration speichern, z. B. einen Pfad zur Datenquelle.

Das Festlegen eines DataContext ist praktisch, um mehrere Bindungen verschiedener Eigenschaften für dasselbe Objekt auf einen freigegebenen Datenkontext festzulegen. Es gilt jedoch, dass eine DataContext undefiniert ist und dass alle erforderlichen verbindlichen Qualifikationen in separaten verbindlichen Erklärungen vorhanden sind.

Wie Sie die Objektdatenquelle implementieren, hängt von Ihren Anforderungen und Ihrer Programmiersprache ab. Weitere Informationen finden Sie unter Datenbindung im Detail.

Ein häufiges Szenario für C#-Datenkontexte ist die Verwendung eines CLR-definierten Geschäftsobjekts, das Änderungsbenachrichtigungen unterstützt. Für ein Geschäftsobjekt implementiert die benutzerdefinierte Klasse, die als Datenkontext verwendet wird, INotifyPropertyChanged, sodass aktualisierungen der Daten eine unidirektionale oder bidirektionale Bindung aktualisieren können. Wenn die Datenquelle eine Sammlung von Geschäftsobjekten ist, kann sie INotifyCollectionChanged plus Listenunterstützung (IList oder List) implementieren oder von ObservableCollection abgeleitet werden.

Gilt für:

Weitere Informationen