FrameworkElement.DataContext Proprietà

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

Valore della proprietà

Oggetto da usare come contesto dei dati.

Esempio

In questo esempio l'oggetto viene impostato direttamente su un'istanza DataContext di una classe personalizzata.

Se usi C++/WinRT e l'estensione di markup {Binding} , userai la FrameworkElement::DataContext proprietà e BindableAttribute. Se si usa l'estensione di markup {x:Bind}, non si userà FrameworkElement::DataContext né .BindableAttribute

Per altre informazioni sull'esempio di codice C++/WinRT riportato di seguito (ad esempio, come usare l'elenco .idl di file e cosa fare con i file di implementazione generati), vedi Controlli XAML; binding a una proprietà 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;

Commenti

Il contesto dei dati è un concetto in cui gli oggetti possono ereditare le informazioni di data binding da oggetti padre successivi in una gerarchia di relazioni tra oggetti.

L'aspetto più importante del contesto dati è l'origine dati usata per il data binding. Un uso tipico di DataContext consiste nell'impostarlo direttamente su un oggetto origine dati. Questa origine dati può essere un'istanza di una classe, ad esempio un oggetto business. In alternativa, è possibile creare un'origine dati come raccolta osservabile, in modo che il contesto dei dati consenta di rilevare le modifiche nella raccolta di backup. Se l'origine dati è definita da una libreria inclusa anche nel progetto, l'impostazione di viene DataContext spesso combinata con la creazione di un'istanza dell'origine dati come risorsa con chiave in un Oggetto ResourceDictionary e quindi impostando in XAML con un riferimento all'estensione DataContext di markup {StaticResource} .

Un'altra tecnica per l'impostazione DataContext consiste nell'aggiungerla alla radice dell'albero degli oggetti di runtime, come parte della logica di inizializzazione dell'app, subito dopo aver chiamato InitializeComponent. Questa tecnica è illustrata in Panoramica del data binding.

Oltre a specificare l'origine, un contesto dati può anche archiviare caratteristiche aggiuntive di una dichiarazione di associazione, ad esempio un percorso nell'origine dati.

L'impostazione di un DataContext oggetto è utile per impostare più associazioni di proprietà diverse sullo stesso oggetto su un contesto di dati condiviso. Tuttavia, è valido che un oggetto DataContext non sia definito e che tutte le qualifiche di associazione necessarie esistano in istruzioni di associazione separate.

La modalità di implementazione dell'origine dati dell'oggetto varia a seconda dei requisiti e del linguaggio di programmazione. Per altre info, vedi Informazioni approfondite sul data binding.

Uno scenario comune per i contesti di dati C# consiste nell'usare un oggetto business clr definito da CLR che supporta la notifica delle modifiche. Per un oggetto business, la classe personalizzata usata come contesto dati implementa in genere INotifyPropertyChanged, in modo che gli aggiornamenti ai dati possano aggiornare un'associazione unidirezionale o bidirezionale. Se l'origine dati è una raccolta di oggetti business, può implementare INotifyCollectionChanged più il supporto dell'elenco (IList o List) o derivare da ObservableCollection.

Si applica a

Vedi anche

• Binding
• Informazioni approfondite sul data binding
• ObservableCollection<T>