Compartilhar via

FrameworkElement.DataContext Propriedade

  • Referência

Definição

Namespace:
Microsoft.UI.Xaml
Editar

Obtém ou define o contexto de dados de um FrameworkElement. Um uso comum de um contexto de dados é quando um FrameworkElement usa a extensão de marcação {Binding} e participa da associação de dados.

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 da propriedade

Object

Platform::Object

IInspectable

O objeto a ser usado como contexto de dados.

Exemplos

Este exemplo define o DataContext diretamente para uma instância de uma classe personalizada.

Se você estiver usando C++/WinRT e a extensão de marcação {Binding} , use a FrameworkElement::DataContext propriedade e o BindableAttribute. Se você estiver usando a extensão de marcação {x:Bind} , não usará FrameworkElement::DataContext nem o BindableAttribute.

Para obter mais informações sobre o exemplo de código C++/WinRT abaixo (por exemplo, como usar a .idl listagem de arquivos e o que fazer com os arquivos de implementação gerados para você), consulte Controles XAML; associar a uma propriedade 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;

Comentários

O contexto de dados é um conceito em que os objetos podem herdar informações de associação de dados de objetos pai sucessivos em uma hierarquia de relação de objeto.

O aspecto mais importante do contexto de dados é a fonte de dados usada para associação de dados. Um uso típico de DataContext é defini-lo diretamente para um objeto de fonte de dados. Essa fonte de dados pode ser uma instância de uma classe, como um objeto de negócios. Ou você pode criar uma fonte de dados como uma coleção observável, para que o contexto de dados permita detectar alterações na coleção de backup. Se a fonte de dados for definida por uma biblioteca que também está incluída no projeto, a configuração de um DataContext geralmente será combinada com a instanciação da fonte de dados como um recurso com chave em um ResourceDictionary e, em seguida, definindo o DataContext em XAML com uma referência de extensão de marcação {StaticResource} .

Outra técnica para a configuração DataContext é adicioná-la à raiz da árvore de objetos de runtime, como parte da lógica de inicialização do aplicativo, logo após chamar InitializeComponent. Essa técnica é mostrada na Visão geral da associação de dados.

Além de especificar a origem, um contexto de dados também pode armazenar características adicionais de uma declaração de associação, como um caminho para a fonte de dados.

Definir um DataContext é conveniente para definir várias associações de propriedades diferentes no mesmo objeto para um contexto de dados compartilhados. No entanto, é válido que um DataContext seja indefinido e que todas as qualificações de associação necessárias existam em instruções de associação separadas.

A forma como você implementa a fonte de dados do objeto varia de acordo com seus requisitos e sua linguagem de programação. Para obter mais informações, consulte Vinculação de dados em detalhes.

Um cenário comum para contextos de dados C# é usar um objeto de negócios definido por CLR que dê suporte à notificação de alteração. Para um objeto de negócios, a classe personalizada usada como contexto de dados normalmente implementa INotifyPropertyChanged, para que as atualizações nos dados possam atualizar uma associação unidirecional ou bidirecional. Se a fonte de dados for uma coleção de objetos de negócios, ela poderá implementar o suporte de lista de mais INotifyCollectionChanged (IList ou List) ou derivar de ObservableCollection.

Aplica-se a

Confira também