DependencyObject Classe

  • Referência

Definição

Namespace:
Microsoft.UI.Xaml
Editar

Representa um objeto que participa do sistema de propriedade de dependência.

public ref class DependencyObject
/// [Windows.Foundation.Metadata.ContractVersion(Microsoft.UI.Xaml.WinUIContract, 65536)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
class DependencyObject
[Windows.Foundation.Metadata.ContractVersion(typeof(Microsoft.UI.Xaml.WinUIContract), 65536)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
public class DependencyObject
Public Class DependencyObject
Herança
Object Platform::Object IInspectable DependencyObject
Derivado
Atributos
ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Exemplos

Este exemplo define uma classe que deriva de DependencyObjecte define uma propriedade anexada junto com o campo identificador. O cenário para essa classe é que é uma classe de serviço que declara uma propriedade anexada que outros elementos de interface do usuário podem definir em XAML O serviço potencialmente atua nos valores de propriedade anexada nesses elementos de interface do usuário em tempo de execução.

public abstract class AquariumServices : DependencyObject
{
    public enum Buoyancy { Floats, Sinks, Drifts }

    public static readonly DependencyProperty BuoyancyProperty = DependencyProperty.RegisterAttached(
      "Buoyancy",
      typeof(Buoyancy),
      typeof(AquariumServices),
      new PropertyMetadata(Buoyancy.Floats)
    );
    public static void SetBuoyancy(DependencyObject element, Buoyancy value)
    {
        element.SetValue(BuoyancyProperty, value);
    }
    public static Buoyancy GetBuoyancy(DependencyObject element)
    {
        return (Buoyancy)element.GetValue(BuoyancyProperty);
    }
}

public static bool ClearSetProperty(DependencyObject targetObject, DependencyProperty targetDP)
{
    if (targetObject == null || targetDP == null)
    {
        throw new ArgumentNullException();
    }
    object localValue = targetObject.ReadLocalValue(targetDP);
    if (localValue == DependencyProperty.UnsetValue)
    {
        return false;
    }
    else
    {
        targetObject.ClearValue(targetDP);
        return true;
    }
}

Este exemplo mostra uma declaração de propriedade de dependência simples. Uma chamada para GetValue constitui a totalidade da implementação do get acessador para o wrapper de propriedade da nova propriedade de dependência. Uma chamada para SetValue constitui a totalidade da implementação do set acessador. Para obter mais exemplos, consulte Propriedades de dependência personalizadas.

public class Fish : Control
{
    public static readonly DependencyProperty SpeciesProperty =
    DependencyProperty.Register(
    "Species",
    typeof(String),
    typeof(Fish), null
    );
    public string Species
    {
        get { return (string)GetValue(SpeciesProperty); }
        set { SetValue(SpeciesProperty, (string)value); }
    }
}

Comentários

A DependencyObject classe habilita os serviços do sistema de propriedades de dependência em suas muitas classes derivadas e é a classe base imediata de muitas classes importantes relacionadas à interface do usuário, como UIElement, Geometry, FrameworkTemplate, Style e ResourceDictionary. Para obter mais informações sobre como o DependencyObject dá suporte a propriedades de dependência, consulte Visão geral das propriedades de dependência.

A função primária do sistema de propriedades de dependência é calcular os valores das propriedades e fornecer notificação do sistema sobre valores que foram alterados. Outra classe de chave que participa do sistema de propriedades de dependência é DependencyProperty. DependencyProperty permite o registro de propriedades de dependência no sistema de propriedades, enquanto DependencyObject como uma classe base permite que os objetos usem e defina as propriedades de dependência.

Aqui estão alguns serviços e características notáveis que DependencyObject fornece ou dá suporte:

  • Suporte à hospedagem de propriedade de dependência para as propriedades de dependência Windows Runtime existentes.
  • Suporte à hospedagem de propriedade de dependência personalizada. Registre uma propriedade de dependência chamando o método Register e armazenando o valor retornado do método como uma propriedade estática pública em sua DependencyObject classe.
  • Suporte à hospedagem de propriedade anexada para as propriedades anexadas Windows Runtime existentes.
  • Suporte à hospedagem de propriedade anexada personalizada. Registre uma propriedade de dependência para o uso da propriedade anexada chamando o método RegisterAttached e armazenando o valor retornado do método como uma propriedade estática pública em sua classe.
  • Get e Set métodos utilitários para valores de quaisquer propriedades de dependência que existem em um DependencyObject. Você os usa ao definir wrappers de propriedade de dependência personalizados e também pode usá-los do código do aplicativo como uma alternativa ao uso de propriedades de wrapper existentes.
  • Utilitário de cenário avançado para examinar metadados ou valores de propriedade (por exemplo , GetAnimationBaseValue).
  • Imposição de afinidade de thread para o thread de interface do usuário main do Windows Runtime para todas as DependencyObject instâncias.
  • A propriedade DispatcherQueue para cenários avançados de threading. O DispatcherQueue permite que um thread de trabalho execute o código que usa um DependencyObject , mas não está no thread da interface do usuário, porque ele pode adiar a execução para uma operação assíncrona que não bloqueará ou interferirá no thread da interface do usuário. Veja a seção "DependencyObject e threading" abaixo.
  • Suporte básico à associação de dados e estilo, permitindo que as propriedades sejam definidas como expressões a serem avaliadas posteriormente no tempo de vida de um objeto. Esses conceitos são explicados mais detalhadamente em Visão geral das propriedades de dependência. Confira também Associação de dados em detalhes.

DependencyObject e threading

Todas as DependencyObject instâncias devem ser criadas no thread da interface do usuário associado à janela atual de um aplicativo. Isso é imposto pelo sistema e há duas implicações importantes disso para seu código:

  • O código que usa a API de duas DependencyObject instâncias sempre será executado no mesmo thread, que é sempre o thread da interface do usuário. Normalmente, você não tem problemas de threading nesse cenário.
  • O código que não está em execução no thread de interface do usuário do main não pode acessar um DependencyObject diretamente porque um DependencyObject tem afinidade de thread apenas com o thread de interface do usuário. Somente o código executado no thread da interface do usuário pode alterar ou até mesmo ler o valor de uma propriedade de dependência. Por exemplo, um thread de trabalho que você iniciou com uma Tarefa .NET ou um thread ThreadPool explícito não poderá ler propriedades de dependência ou chamar outras APIs.

Você não está completamente impedido de usar um de um DependencyObject thread de trabalho. Mas você deve obter um objeto DispatcherQueue (o valor de DependencyObject.DispatcherQueue) de um DependencyObject para atravessar a separação deliberada entre o thread da interface do usuário do aplicativo e quaisquer outros threads em execução no sistema. O DispatcherQueue expõe o método TryEnqueue para executar seu código de espera. Como ele está habilitando o acesso entre threads, DependencyObject.DispatcherQueue é a única API de instância de DependencyObject ou qualquer uma de suas subclasses que pode ser acessada de um thread que não é da interface do usuário sem gerar uma exceção entre threads. Todas as outras DependencyObject APIs geram uma exceção se você tentar chamá-las de um thread de trabalho ou de qualquer outro thread que não seja da interface do usuário.

Geralmente, os problemas de threading podem ser evitados no código de interface do usuário típico. No entanto, os dispositivos geralmente não são associados ao thread da interface do usuário. Se você estiver usando informações obtidas de um dispositivo para atualizar a interface do usuário em tempo real, geralmente deverá obter um DispatcherQueue para que possa atualizar a interface do usuário. Os serviços são outro caso em que o código que você usa para acessar o serviço pode não estar em execução no thread da interface do usuário.

Um cenário de código em que você pode encontrar DependencyObjectproblemas de threading relacionados a se você estiver definindo seus próprios DependencyObject tipos e tentar usá-los para fontes de dados ou outros cenários em que um DependencyObject não é necessariamente apropriado (porque o objeto não está diretamente relacionado à interface do usuário). Por exemplo, você pode estar tentando otimizações de perf com threads em segundo plano ou outros threads de trabalho que estão alterando valores dos objetos antes da apresentação ou em resposta a um dispositivo, serviço ou outra entrada externa. Avalie se você realmente precisa de propriedades de dependência para seu cenário; talvez as propriedades padrão sejam adequadas.

Classes derivadas de DependencyObject

DependencyObject é a classe pai de várias classes imediatamente derivadas que são fundamentais para o modelo de programação que você usa para seu aplicativo e sua interface do usuário XAML. Aqui estão algumas das classes derivadas notáveis:

Construtores

DependencyObject()

Fornece o comportamento de inicialização de classe base para classes derivadas de DependencyObject .

Propriedades

Dispatcher

Sempre retorna null em um aplicativo SDK do Aplicativo Windows. Em vez disso, use DispatcherQueue .
DispatcherQueue

Obtém o ao DispatcherQueue qual este objeto está associado. O DispatcherQueue representa uma instalação que pode acessar o DependencyObject no thread da interface do usuário, mesmo que o código seja iniciado por um thread que não seja da interface do usuário.

Métodos

ClearValue(DependencyProperty)

Limpa o valor local de uma propriedade de dependência.
GetAnimationBaseValue(DependencyProperty)

Retorna qualquer valor base estabelecido para uma propriedade de dependência, que se aplicaria nos casos em que uma animação não está ativa.
GetValue(DependencyProperty)

Retorna o valor efetivo atual de uma propriedade de dependência de um DependencyObject.
ReadLocalValue(DependencyProperty)

Retorna o valor local de uma propriedade de dependência, se um valor local for definido.
RegisterPropertyChangedCallback(DependencyProperty, DependencyPropertyChangedCallback)

Registra uma função de notificação para escutar alterações em uma DependencyProperty específica nessa instância dependencyObject .
SetValue(DependencyProperty, Object)

Define o valor local de uma propriedade de dependência em um DependencyObject.
UnregisterPropertyChangedCallback(DependencyProperty, Int64)

Cancela uma notificação de alteração que foi registrada anteriormente chamando RegisterPropertyChangedCallback.

Aplica-se a

Confira também