FrameworkElement.DataContext Propiedad
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Obtiene o establece el contexto de datos de un FrameworkElement. Un uso común de un contexto de datos es cuando usa FrameworkElement la extensión de marcado {Binding} y participa en el enlace de datos.
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}"/>
Valor de propiedad
Objeto que se va a usar como contexto de datos.
Ejemplos
En este ejemplo se establece directamente DataContext en una instancia de una clase personalizada.
Si usa C++/WinRT y la extensión de marcado {Binding} , usará la FrameworkElement::DataContext propiedad y BindableAttribute. Si usa la extensión de marcado {x:Bind}, no usará FrameworkElement::DataContext ni .BindableAttribute
Para obtener más información sobre el ejemplo de código de C++/WinRT siguiente (por ejemplo, cómo usar la .idl lista de archivos y qué hacer con los archivos de implementación que genera), consulta Controles XAML; enlazar a una propiedad 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;
Comentarios
El contexto de datos es un concepto en el que los objetos pueden heredar información de enlace de datos de objetos primarios sucesivos en una jerarquía de relaciones de objetos.
El aspecto más importante del contexto de datos es el origen de datos que se usa para el enlace de datos. Un uso típico de es establecerlo directamente en un objeto de origen de DataContext datos. Este origen de datos puede ser una instancia de una clase como un objeto de negocio. O bien, puede crear un origen de datos como una colección observable, de modo que el contexto de datos permita detectar cambios en la colección de respaldo. Si el origen de datos se define mediante una biblioteca que también se incluye en el proyecto, establecer un DataContext se combina a menudo con la creación de instancias del origen de datos como un recurso con clave en un ResourceDictionary y, a continuación, establecer el DataContext en XAML con una referencia de extensión de marcado {StaticResource} .
Otra técnica para establecer DataContext es agregarla a la raíz del árbol de objetos en tiempo de ejecución, como parte de la lógica de inicialización de la aplicación, justo después de llamar a InitializeComponent. Esta técnica se muestra en Introducción al enlace de datos.
Además de especificar el origen, un contexto de datos también puede almacenar características adicionales de una declaración de enlace, como una ruta de acceso al origen de datos.
Establecer un DataContext es conveniente para establecer varios enlaces de propiedades diferentes en el mismo objeto en un contexto de datos compartido. Sin embargo, es válido para que un DataContext elemento no esté definido y para que todas las calificaciones de enlace necesarias existan en instrucciones de enlace independientes.
La forma de implementar el origen de datos del objeto varía en función de sus requisitos y del lenguaje de programación. Para obtener más información, consulta el tema Enlace de datos en profundidad.
Un escenario común para los contextos de datos de C# es usar un objeto de negocio definido por CLR que admita la notificación de cambios. Para un objeto de negocio, la clase personalizada que se usa como contexto de datos normalmente implementa INotifyPropertyChanged, para que las actualizaciones de los datos puedan actualizar un enlace unidireccional o bidireccional. Si el origen de datos es una colección de objetos empresariales, puede implementar INotifyCollectionChanged más compatibilidad con listas (IList o List) o derivar de ObservableCollection.