FrameworkElement.DataContext Propiedad

  • Referencia

Definición

Espacio de nombres:
Windows.UI.Xaml
Editar

Obtiene o establece el contexto de datos de un FrameworkElement. Un uso común de un contexto de datos es cuando frameworkElement usa 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

Object

Platform::Object

IInspectable

Objeto que se va a usar como contexto de datos.

Ejemplos

En este ejemplo se establece DataContext directamente en una instancia de una clase personalizada.

Si usaS C++/WinRT y la extensión de marcado {Binding} , usarás la propiedad FrameworkElement::D ataContext y BindableAttribute. Si usa la extensión de marcado {x:Bind} , no usará FrameworkElement::D ataContext 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;

' 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

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 DataContext es establecerlo directamente en un objeto de origen de 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, el establecimiento de 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, se establece 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 que dataContext no esté definido y que todas las calificaciones de enlace necesarias existan en instrucciones de enlace independientes.

La forma de implementar el origen de datos de objeto varía en función de los 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# y Microsoft Visual Basic es usar un objeto empresarial 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, de modo 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.

Se aplica a

Consulte también