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

In questo esempio viene definita una classe derivata da DependencyObject e viene definita una proprietà associata insieme al campo identificatore. Lo scenario per questa classe è che è una classe di servizio che dichiara una proprietà associata che altri elementi dell'interfaccia utente possono impostare in XAML Il servizio potenzialmente agisce 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 relative numerose classi derivate. Per altre informazioni sul concetto di proprietà di dipendenza, vedere 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 che sono stati modificati. Un'altra classe chiave che partecipa al sistema delle 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 per l'hosting di proprietà di dipendenza personalizzate. 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 delle proprietà associate per le proprietà associate Windows Runtime esistenti.
• Supporto per l'hosting di proprietà associate personalizzate. Per registrare una proprietà di dipendenza per l'utilizzo della proprietà associata, 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 tutte le proprietà di dipendenza esistenti in dependencyObject. Questi vengono usati quando si definiscono proprietà di dipendenza personalizzate "wrapper" e possono essere usati anche dal codice dell'app come alternativa all'uso delle proprietà "wrapper" esistenti.
• Utilità dello scenario avanzato per l'analisi dei metadati o dei valori delle proprietà, ad esempio GetAnimationBaseValue.
• Imposizione dell'affinità di thread al thread principale dell'interfaccia utente 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 è presente nel thread dell'interfaccia utente, perché CoreDispatcher può rinviare l'esecuzione a un'operazione asincrona che non blocca o interferisce altrimenti 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 vengono illustrati in modo più dettagliato in Panoramica delle proprietà di dipendenza. Vedere anche Data binding in modo approfondito.

DependencyObject e threading

Tutte le istanze di DependencyObject devono essere create nel thread dell'interfaccia utente associato alla finestra corrente per un'app. Questo viene applicato dal sistema e ci sono due importanti implicazioni di questo per il codice:

• Il codice che usa l'API da due istanze di DependencyObject verrà sempre eseguito nello 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 principale dell'interfaccia utente non può accedere direttamente a DependencyObject perché dependencyObject ha l'affinità di thread solo con il thread dell'interfaccia utente. Solo il codice eseguito nel thread dell'interfaccia utente può modificare o persino 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 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 si tratta di codice semplice, è possibile usare un'espressione lambda; in caso contrario, è 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 è possibile che si verifichino problemi di threading correlati a DependencyObject se si definiscono tipi DependencyObject personalizzati 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, un servizio o un altro input esterno. Valutare se sono effettivamente necessarie proprietà di dipendenza per lo scenario in uso; 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 di stato di visualizzazione: Transition, 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.
• Creazione di immagini e interoperabilità della superficie di 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, a sua volta sono classi di base per gli elementi di testo usati per il contenuto TextBlock o gli elementi rtf.
• AutomationPeer: classe di base per i peer di Microsoft Automazione interfaccia utente che rappresentano i controlli XAML a un listener di Microsoft Automazione interfaccia utente. Inoltre, IRawElementProviderSimple.
• Varie: CacheMode, ColumnDefinition, DependencyObjectCollection, InputScope, InputScopeName, PageStackEntry, PrintDocument, RowDefinition, TimelineMarker, TriggerAction, TriggerBase.

Costruttori

Proprietà

Metodi

Si applica a

Vedi anche

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