DependencyObject Classe

Definição

public ref class DependencyObject

/// [Windows.Foundation.Metadata.ContractVersion(Windows.Foundation.UniversalApiContract, 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(Windows.Foundation.UniversalApiContract), 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

Windows.UI.Xaml.Automation.AutomationAnnotation

Windows.UI.Xaml.Automation.Peers.AutomationPeer

Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation

Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple

Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs

Mais…

Atributos

ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Requisitos do Windows

Exemplos

Este exemplo define uma classe derivada de DependencyObject e 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 Class AquariumServices
    Inherits DependencyObject
    Public Enum Buoyancy
        Floats
        Sinks
        Drifts
    End Enum

    Public Shared ReadOnly BuoyancyProperty As DependencyProperty = _
          DependencyProperty.RegisterAttached(
          "Buoyancy", _
          GetType(Buoyancy), _
          GetType(AquariumServices), _
          New PropertyMetadata(Buoyancy.Floats))


    Public Sub SetBuoyancy(element As DependencyObject, value As Buoyancy)
        element.SetValue(BuoyancyProperty, value)
    End Sub
    Public Function GetBuoyancy(element As DependencyObject) As Buoyancy
        GetBuoyancy = CType(element.GetValue(BuoyancyProperty), Buoyancy)
    End Function
End Class

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;
    }
}

Public Shared Function ClearSetProperty(targetObject As DependencyObject, targetDP As DependencyProperty) As Boolean
    If targetObject Is Nothing Or targetDP Is Nothing Then
        Throw New ArgumentNullException()
    End If
    Dim localValue As Object = targetObject.ReadLocalValue(targetDP)
    If localValue = DependencyProperty.UnsetValue Then
        ClearSetProperty = False
    Else
        targetObject.ClearValue(targetDP)
        ClearSetProperty = True
    End If
End Function

Este exemplo mostra uma declaração de propriedade de dependência simples. Uma chamada para GetValue constitui a totalidade da implementação do acessador get para o wrapper de propriedade da nova propriedade de dependência. Uma chamada para SetValue constitui a totalidade da implementação do acessador set . 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); }
    }
}

Public Class Fish
    Inherits Control

    Public Shared ReadOnly SpeciesProperty As DependencyProperty = _
    DependencyProperty.Register(
    "Species", _
    GetType(String), _
    GetType(Fish), _
    Nothing)
    Public Property Species As String
        Get
            Species = CType(GetValue(SpeciesProperty), String)
        End Get
        Set(value As String)
            SetValue(SpeciesProperty, value)
        End Set
    End Property
End Class

Comentários

A classe DependencyObject permite serviços do sistema de propriedades de dependência em suas muitas classes derivadas. Para obter mais informações sobre o conceito de propriedade 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 classe DependencyObject.
• 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.
• Obter e definir métodos de utilitário para valores de quaisquer propriedades de dependência que existam em um DependencyObject. Use-os ao definir a propriedade de dependência personalizada "wrappers" e também pode usá-los no código do aplicativo como uma alternativa ao uso de propriedades "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 instâncias dependencyObject.
• A propriedade Dispatcher para cenários avançados de threading. Obter o valor dispatcher fornece uma referência a um objeto CoreDispatcher . Com o CoreDispatcher, um thread de trabalho pode executar código que usa dependencyObject, mas não está no thread da interface do usuário, porque o CoreDispatcher pode adiar a execução para uma operação assíncrona que não bloqueará ou interferirá no thread da interface do usuário. Consulte 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 instâncias dependencyObject 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 instâncias dependencyObject 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 somente 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 DependencyObject de um thread de trabalho. Mas você deve obter um objeto CoreDispatcher (o valor de DependencyObject.Dispatcher) de um DependencyObject para obter a separação deliberada entre o thread da interface do usuário do aplicativo e quaisquer outros threads em execução no sistema. O CoreDispatcher expõe o método RunAsync . Chame RunAsync para executar seu código aguardável (um IAsyncAction). Se for um código simples, você poderá usar uma expressão lambda, caso contrário, poderá implementar como um delegado (DispatchedHandler). O sistema determina uma hora em que seu código pode ser executado. Como está habilitando o acesso entre threads, DependencyObject.Dispatcher é 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 APIs DependencyObject lançarão 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.

Os problemas de threading geralmente podem ser evitados no código típico da interface do usuário. No entanto, os dispositivos geralmente não estã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 CoreDispatcher 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 problemas de threading relacionados a DependencyObject se estiver definindo seus próprios tipos DependencyObject e tentar usá-los para fontes de dados ou outros cenários em que 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 desempenho 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 derivadas imediatamente 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:

• UIElement: a classe base para a maioria dos objetos visuais que podem processar a entrada na interface do usuário. FrameworkElement está mais nessa hierarquia, assim como Control, portanto, há centenas de controles e outras classes no Windows Runtime que todos têm a classe UIElement em suas hierarquias de classe.
• Classes de suporte do sistema de estilo XAML: FrameworkTemplate (pai de ControlTemplate, DataTemplate, ItemsPanelTemplate), Style, SetterBase (pai de Setter), ToolTipTemplateSettings e outros *TemplateSettings.
• Modelo de estado visual: Transition, VisualState, VisualStateGroup, VisualStateManager, VisualTransition.
• Suporte à associação de dados: BindingBase (pai de Binding), CollectionViewSource, PropertyPath, RelativeSource.
• Animações com storyboard: Linha do tempo (pai de Storyboard, animações digitadas, animações de tema), quadros-chave digitados (como ColorKeyFrame), KeySpline, EasingFunctionBase.
• Elementos gráficos XAML e primitivos de renderização: Brush, Geometry, GeneralTransform, GradientStop, PathFigure, PathSegment, Projection.
• Interoperabilidade de superfície de geração de imagens e renderização: ImageSource (pai de BitmapSource, RenderTargetBitmap, SurfaceImageSource e outros).
• Janela: representa a janela main aplicativo.
• FlyoutBase (pai de Flyout e MenuFlyout).
• ResourceDictionary: define recursos com chave em XAML.
• TextElement: pai de Block e Inline, eles, por sua vez, são classes base para elementos de texto usados para o conteúdo TextBlock ou os elementos rich text.
• AutomationPeer: classe base para pares da Automação da Interface do Usuário da Microsoft que representam controles XAML para um ouvinte da Automação da Interface do Usuário da Microsoft. Além disso, IRawElementProviderSimple.
• Diversos: CacheMode, ColumnDefinition, DependencyObjectCollection, InputScope, InputScopeName, PageStackEntry, PrintDocument, RowDefinition, TimelineMarker, TriggerAction, TriggerBase.

Construtores

Propriedades

Métodos

Aplica-se a

Confira também

• DependencyProperty
• Visão geral das propriedades de dependência
• Propriedades de dependência personalizadas
• Propriedades anexadas personalizadas
• Visão geral das propriedades anexadas