DependencyObject Classe

Definizione

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

Ereditarietà

Object Platform::Object IInspectable DependencyObject

Derivato

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

Altro…

Attributi

ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Requisiti Windows

Esempio

Questo esempio definisce una classe che deriva da DependencyObject e definisce una proprietà associata insieme al campo dell'identificatore. Lo scenario per questa classe è che si tratta di una classe di servizio che dichiara una proprietà associata che altri elementi dell'interfaccia utente possono impostare in XAML Il servizio agisce potenzialmente sui valori delle proprietà associate su tali elementi dell'interfaccia utente in fase di esecuzione.

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

In questo esempio viene illustrata una semplice dichiarazione di proprietà di dipendenza. Una chiamata a GetValue costituisce l'intera implementazione della funzione di accesso get per il wrapper delle proprietà della nuova proprietà di dipendenza. Una chiamata a SetValue costituisce l'intera implementazione della funzione di accesso set . Per altri esempi, vedere Proprietà di dipendenza personalizzate.

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

Commenti

La classe DependencyObject abilita i servizi di sistema delle proprietà di dipendenza nelle numerose classi derivate. Per altre info sul concetto di proprietà di dipendenza, vedi Panoramica delle proprietà di dipendenza.

La funzione primaria del sistema delle proprietà di dipendenza consiste nel calcolare i valori delle proprietà e fornire una notifica di sistema sui valori modificati. Un'altra classe chiave che partecipa al sistema di proprietà di dipendenza è DependencyProperty. DependencyProperty consente la registrazione delle proprietà di dipendenza nel sistema di proprietà, mentre DependencyObject come classe di base consente agli oggetti di usare e impostare le proprietà di dipendenza.

Ecco alcuni servizi e caratteristiche rilevanti forniti da DependencyObject o supportati:

• Supporto dell'hosting delle proprietà di dipendenza per le proprietà di dipendenza Windows Runtime esistenti.
• Supporto dell'hosting di proprietà di dipendenza personalizzato. Per registrare una proprietà di dipendenza, chiamare il metodo Register e archiviare il valore restituito del metodo come proprietà statica pubblica nella classe DependencyObject.
• Supporto dell'hosting di proprietà associate per le proprietà associate Windows Runtime esistenti.
• Supporto personalizzato per l'hosting di proprietà associate. Per registrare una proprietà di dipendenza per l'utilizzo delle proprietà associate, chiamare il metodo RegisterAttached e archiviare il valore restituito del metodo come proprietà statica pubblica nella classe.
• Metodi di utilità Get e Set per i valori di qualsiasi proprietà di dipendenza esistente in dependencyObject. Questi vengono usati durante la definizione di "wrapper" della proprietà di dipendenza personalizzata e possono essere usati anche dal codice dell'app come alternativa all'uso delle proprietà "wrapper" esistenti.
• Utilità avanzata dello scenario per l'analisi dei metadati o dei valori delle proprietà, ad esempio GetAnimationBaseValue.
• Imposizione dell'affinità di thread al thread dell'interfaccia utente principale del Windows Runtime per tutte le istanze di DependencyObject.
• Proprietà Dispatcher per scenari di threading avanzati. Il recupero del valore dispatcher fornisce un riferimento a un oggetto CoreDispatcher . Con CoreDispatcher, un thread di lavoro può eseguire codice che usa dependencyObject ma non è nel thread dell'interfaccia utente, perché CoreDispatcher può rinviare l'esecuzione a un'operazione asincrona che non blocca o interferisce in altro modo con il thread dell'interfaccia utente. Vedere la sezione "DependencyObject e threading" di seguito.
• Supporto di data binding e stili di base, abilitando l'impostazione delle proprietà come espressioni da valutare in un secondo momento nella durata di un oggetto. Questi concetti sono illustrati in modo più dettagliato in Panoramica delle proprietà di dipendenza. Vedere anche Data binding approfondito.

DependencyObject e thread

Tutte le istanze di DependencyObject devono essere create nel thread dell'interfaccia utente associato alla finestra corrente per un'app. Questa operazione viene applicata dal sistema e ciò comporta due importanti implicazioni per il codice:

• Il codice che usa l'API di due istanze dependencyObject verrà sempre eseguito sullo stesso thread, che è sempre il thread dell'interfaccia utente. In genere non si verificano problemi di threading in questo scenario.
• Il codice che non è in esecuzione nel thread dell'interfaccia utente principale non può accedere direttamente a DependencyObject perché dependencyObject ha affinità di thread solo con il thread dell'interfaccia utente. Solo il codice eseguito nel thread dell'interfaccia utente può modificare o anche leggere il valore di una proprietà di dipendenza. Ad esempio, un thread di lavoro avviato con un'attività .NET o un thread ThreadPool esplicito non sarà in grado di leggere le proprietà di dipendenza o chiamare altre API.

Non è completamente impedito l'uso di dependencyObject da un thread di lavoro. È tuttavia necessario ottenere un oggetto CoreDispatcher (il valore di DependencyObject.Dispatcher) da un DependencyObject per ottenere la separazione deliberata tra il thread dell'interfaccia utente dell'app e qualsiasi altro thread in esecuzione nel sistema. CoreDispatcher espone il metodo RunAsync. Chiamare RunAsync per eseguire il codice awaitable ( IAsyncAction). Se è un codice semplice, è possibile usare un'espressione lambda, altrimenti è possibile implementare come delegato (DispatchedHandler). Il sistema determina un'ora in cui è possibile eseguire il codice. Poiché abilita l'accesso tra thread, DependencyObject.Dispatcher è l'unica API di istanza di DependencyObject o una delle relative sottoclassi a cui è possibile accedere da un thread non dell'interfaccia utente senza generare un'eccezione tra thread. Tutte le altre API DependencyObject generano un'eccezione se si tenta di chiamarle da un thread di lavoro o da qualsiasi altro thread non dell'interfaccia utente.

I problemi di threading possono in genere essere evitati nel codice tipico dell'interfaccia utente. Tuttavia, i dispositivi non sono in genere associati al thread dell'interfaccia utente. Se si usano informazioni ottenute da un dispositivo per aggiornare l'interfaccia utente in tempo reale, spesso è necessario ottenere un CoreDispatcher in modo da poter aggiornare l'interfaccia utente. I servizi sono un altro caso in cui il codice usato per accedere al servizio potrebbe non essere in esecuzione nel thread dell'interfaccia utente.

Uno scenario di codice in cui potrebbero verificarsi problemi di threading correlati a DependencyObject se si definiscono i tipi DependencyObject e si tenta di usarli per le origini dati o altri scenari in cui dependencyObject non è necessariamente appropriato (perché l'oggetto non è direttamente correlato all'interfaccia utente). Ad esempio, è possibile tentare di ottimizzare le prestazioni con thread in background o altri thread di lavoro che modificano i valori degli oggetti prima della presentazione o in risposta a un dispositivo, a un servizio o a un altro input esterno. Valutare se sono effettivamente necessarie proprietà di dipendenza per lo scenario; forse le proprietà standard sono adeguate.

Classi derivate dependencyObject

DependencyObject è la classe padre per diverse classi derivate immediatamente fondamentali per il modello di programmazione usato per l'app e l'interfaccia utente XAML. Ecco alcune delle classi derivate rilevanti:

• UIElement: classe di base per la maggior parte degli oggetti visivi in grado di elaborare l'input nell'interfaccia utente. FrameworkElement è più avanti in questa gerarchia, così come è Control, quindi ci sono centinaia di controlli e altre classi nella Windows Runtime che tutti hanno la classe UIElement nelle gerarchie di classi.
• Classi di supporto del sistema di stile XAML: FrameworkTemplate (padre di ControlTemplate, DataTemplate, ItemsPanelTemplate), Style, SetterBase (padre di Setter), ToolTipTemplateSettings e altri *TemplateSettings.
• Modello dello stato di visualizzazione: Transizione, VisualState, VisualStateGroup, VisualStateManager, VisualTransition.
• Supporto del data binding: BindingBase (padre di Binding), CollectionViewSource, PropertyPath, RelativeSource.
• Animazioni con storyboard: sequenza temporale (padre di Storyboard, animazioni tipate, animazioni a tema), fotogrammi chiave tipizzato (ad esempio ColorKeyFrame), KeySpline, EasingFunctionBase.
• Grafica XAML e primitive di rendering: Brush, Geometry, GeneralTransform, GradientStop, PathFigure, PathSegment, Projection.
• Interoperabilità della superficie di creazione e rendering: ImageSource (padre di BitmapSource, RenderTargetBitmap, SurfaceImageSource e altri).
• Finestra: rappresenta la finestra principale dell'app.
• FlyoutBase (padre di Riquadro a comparsa e MenuFlyout).
• ResourceDictionary: definisce le risorse con chiave in XAML.
• TextElement: elemento padre di Block e Inline, questi a loro volta sono classi di base per gli elementi di testo usati per il contenuto TextBlock o gli elementi rtf.
• AutomationPeer: classe di base per Microsoft Automazione interfaccia utente peer che rappresentano controlli XAML a un listener Microsoft Automazione interfaccia utente. Inoltre, IRawElementProviderSimple.
• Varie: CacheMode, ColumnDefinition, DependencyObjectCollection, InputScope, InputScopeName, PageStackEntry, PrintDocument, RowDefinition, TimelineMarker, TriggerAction, TriggerBase.

Vedi anche

• DependencyProperty
• Panoramica delle proprietà di dipendenza
• Proprietà di dipendenza personalizzate
• Proprietà associate personalizzate
• Panoramica delle proprietà associate