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 utilizzare come contesto dati.

Esempio

In questo esempio 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 di .idl 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 è quello di DataContext impostarlo direttamente su un oggetto origine dati. Questa origine dati potrebbe 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 un DataContext oggetto viene spesso combinata con la creazione di istanze dell'origine dati come risorsa con chiave in un ResourceDictionary e quindi l'impostazione 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 nella 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 è DataContext 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 informazioni, vedere Approfondimento 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<T> o List<T>) o derivare da ObservableCollection<T>.

Vedi anche

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