FrameworkElement.DataContext Proprietà

  • Riferimento

Definizione

Spazio dei nomi:
Windows.UI.Xaml
Modifica

Ottiene o imposta il contesto dati per un FrameworkElement. Un uso comune di un contesto dati è quando un FrameworkElement usa l'estensione di markup {Binding} e partecipa al data binding.

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à

Object

Platform::Object

IInspectable

Oggetto da usare come contesto dei dati.

Esempio

Questo esempio imposta DataContext direttamente su un'istanza di una classe personalizzata.

Se usi C++/WinRT e l'estensione di markup {Binding} , userai la proprietà FrameworkElement::D ataContext e BindableAttribute. Se usi l'estensione di markup {x:Bind} , non userai FrameworkElement::D ataContext 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;

' 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

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 un oggetto DataContext viene spesso combinata con la creazione di un'istanza dell'origine dati come risorsa con chiave in resourceDictionary e quindi l'impostazione di DataContext in XAML con un riferimento all'estensione di markup {StaticResource} .

Un'altra tecnica per l'impostazione di DataContext consiste nell'aggiungerlo 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 oggetto DataContext è utile per impostare più associazioni di proprietà diverse sullo stesso oggetto su un contesto di dati condiviso. È tuttavia possibile 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# e Microsoft Visual Basic 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