FrameworkElement.DataContext Eigenschaft

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

Das Objekt, das als Datenkontext verwendet werden soll.

Beispiele

In diesem Beispiel wird die DataContext direkte Instanz 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 BindableAttributedie .

Weitere Hintergrundinformationen zum folgenden C++/WinRT-Codebeispiel (z. B. verwendung der .idl Dateiauflistung und Was 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 DataContext besteht darin, sie direkt auf ein Datenquellenobjekt festzulegen. Diese Datenquelle kann eine Instanz einer Klasse sein, z. B. ein Geschäftsobjekt. Sie können auch eine Datenquelle als feststellbare Sammlung erstellen, sodass der Datenkontext das Erkennen von Änderungen in der Sicherungsauflistung ermöglicht. Wenn die Datenquelle durch eine Bibliothek definiert wird, die auch im Projekt enthalten ist, wird das Festlegen einer DataContext Datenquelle häufig mit dem Instanziieren der Datenquelle als Schlüsselressource in einem ResourceDictionary kombiniert und anschließend mit DataContext einem {StaticResource}-Markuperweiterungsverweis in XAML festgelegt.

Eine weitere Methode zum Festlegen DataContext ist das Hinzufügen zum Stamm der Laufzeitobjektstruktur im Rahmen der App-Initialisierungslogik direkt nach dem Aufruf InitializeComponent. Diese Technik wird in der Übersicht über die Datenbindung gezeigt.

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

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

Die Implementierung der Objektdatenquelle variiert je nach Ihren Anforderungen und ihrer Programmiersprache. Weitere Informationen finden Sie unter Datenbindung im Detail.

Ein häufiges Szenario für C#-Datenkontexte besteht darin, ein CLR-definiertes Geschäftsobjekt zu verwenden, das Änderungsbenachrichtigungen unterstützt. Bei einem 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 es sich bei der Datenquelle um eine Sammlung von Geschäftsobjekten handelt, kann sie INotifyCollectionChanged plus Listenunterstützung (IList<T> oder List<T>) implementieren oder von ObservableCollection<T> ableiten.

Weitere Informationen

• Binding
• Datenbindung im Detail
• ObservableCollection< T