Freigeben über

FrameworkElement.DataContext Eigenschaft

  • Referenz

Definition

Namespace:
Windows.UI.Xaml
Bearbeiten

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

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 dataContext direkt auf eine instance einer benutzerdefinierten Klasse festgelegt.

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

Weitere Informationen zum C++/WinRT-Codebeispiel finden Sie weiter unten (z. B. wie Sie die .idl Dateiliste verwenden und was mit den Implementierungsdateien zu tun ist, 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;

' 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

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 ein instance einer Klasse wie einem Geschäftsobjekt sein. 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 eines DataContext häufig mit dem Instanziieren der Datenquelle als schlüsselierte Ressource in einem ResourceDictionary kombiniert und anschließend den DataContext in XAML mit einem {StaticResource}-Markuperweiterungsverweis festgelegt.

Eine weitere Technik zum Festlegen von DataContext besteht darin, es dem Stamm der Laufzeitobjektstruktur als Teil der App-Initialisierungslogik hinzuzufügen, direkt nach dem Aufrufen von InitializeComponent. Dieses Verfahren wird in der Übersicht über die Datenbindung veranschaulicht.

Neben der Angabe der Quelle kann ein Datenkontext auch zusätzliche Merkmale einer Bindungsdeklaration speichern, z. B. einen Pfad in die Datenquelle.

Das Festlegen eines DataContext-Objekts eignet sich zum Festlegen mehrerer Bindungen unterschiedlicher Eigenschaften für dasselbe Objekt in einen freigegebenen Datenkontext. Es ist jedoch gültig, dass ein DataContext nicht definiert ist und dass alle erforderlichen Bindungsqualifikationen in separaten Bindungsanweisungen 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 gängiges Szenario für C#- und Microsoft Visual Basic-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 List-Unterstützung (IList oder List) implementieren oder von ObservableCollection ableiten.

Gilt für:

Weitere Informationen