Nell'esempio XAML seguente viene specificato il rosso come colore di sfondo di un pulsante. In questo esempio, viene descritto un caso in cui il caricatore XAML esegue la conversione del tipo del valore di stringa semplice per un attributo XAML in un tipo WPF (un oggetto Color mediante un oggetto SolidColorBrush) nel codice generato.

<Button Background="Red" Content="Button!"/>

XAML supporta diverse sintassi per l'impostazione delle proprietà. La sintassi da utilizzare per una proprietà particolare dipende dal tipo di valore utilizzato da una proprietà e da altri fattori, quali la presenza di un convertitore dei tipi. Per ulteriori informazioni sulla sintassi XAML per l'impostazione delle proprietà, vedere Cenni preliminari su XAML e Terminologia della sintassi XAML.

Nell'esempio XAML seguente viene mostrato lo sfondo di un altro pulsante, come esempio di sintassi senza attributi. Questa volta, invece di impostare un semplice colore a tinta unita, lo sfondo viene impostato su un'immagine, con un elemento che rappresenta tale immagine e la relativa origine, specificate come un attributo dell'elemento nidificato. Si tratta di un esempio di sintassi per gli elementi proprietà.

<Button Content="Button!">
  <Button.Background>
    <ImageBrush ImageSource="wavy.jpg"/>
  </Button.Background>
</Button>

L'impostazione dei valori della proprietà di dipendenza nel codice consiste, in genere, solo in una chiamata all'implementazione definita esposta dal "wrapper" CLR.

Button myButton = new Button();
myButton.Width = 200.0;

Anche l'ottenimento di un valore della proprietà prevede sostanzialmente una chiamata all'implementazione del "wrapper" ottenuta:

double whatWidth;
whatWidth = myButton.Width;

È inoltre possibile chiamare direttamente le API del sistema di proprietà GetValue e SetValue. In genere, questa operazione non è necessaria se si stanno utilizzando proprietà esistenti (i wrapper sono più utili e forniscono una migliore esposizione della proprietà per gli strumenti dello sviluppatore), tuttavia la chiamata diretta delle API risulta appropriata per determinati scenari.

È anche possibile impostare le proprietà in XAML e successivamente accedervi nel codice tramite code-behind. Per informazioni dettagliate, vedere Code-behind e XAML.

Un valore della proprietà di dipendenza può essere impostato facendo riferimento a una risorsa. Le risorse in genere vengono specificate come elementi figlio di un elemento radice della pagina o dell'applicazione (questi percorsi consentono un accesso più semplice alla risorsa). Nell'esempio seguente viene illustrato come definire una risorsa SolidColorBrush.

<DockPanel.Resources>
  <SolidColorBrush x:Key="MyBrush" Color="Gold"/>
</DockPanel.Resources>

Una volta definita, è possibile fare riferimento alla risorsa e utilizzarla per fornire un valore della proprietà:

<Button Background="{DynamicResource MyBrush}" Content="I am gold" />

A questa risorsa particolare viene fatto riferimento come Estensione del markup DynamicResource (in XAML è possibile utilizzare un riferimento di risorsa statica o dinamica). Per utilizzare un riferimento di risorsa dinamica, è necessario eseguire l'impostazione su una proprietà di dipendenza, in modo che il sistema di proprietà WPF attivi l'utilizzo spedifico del riferimento di risorsa dinamica. Per ulteriori informazioni, vedere Cenni preliminari sulle risorse.

Nota:
Le risorse vengono considerate come valore locale, per cui se si imposta un altro valore locale, il riferimento di risorsa sarà eliminato. Per informazioni dettagliate, vedere Precedenza del valore della proprietà di dipendenza.

Una proprietà di dipendenza può fare riferimento a un valore tramite l'associazione dati. Quest'ultima funziona tramite una sintassi per estensione di markup specifica in XAML o mediante l'oggetto Binding nel codice. Con l'associazione dati, la determinazione del valore della proprietà finale viene rinviata fino al runtime, momento in cui il valore viene ottenuto da un'origine dati.

Nell'esempio seguente viene impostata la proprietà Content per un oggetto Button, utilizzando un'associazione in XAML. L'associazione utilizza un contesto dati ereditato e un'origine dati XmlDataProvider (non visualizzata). L'associazione stessa specifica la proprietà di origine desiderata mediante l'oggetto XPath all'interno dell'origine dati.

<Button Content="{Binding XPath=Team/@TeamName}"/>

Nota:
Le associazioni vengono considerate come valore locale, per cui se si imposta un altro valore locale, l'associazione sarà eliminata. Per informazioni dettagliate, vedere Precedenza del valore della proprietà di dipendenza.

Le proprietà di dipendenza o la classe DependencyObject non supportano in modo nativo l'oggetto INotifyPropertyChanged per la produzione delle notifiche delle modifiche del valore della proprietà di origine DependencyObject per le operazioni di associazione dati. Per ulteriori informazioni su come creare proprietà da utilizzare nell'associazione dati che consentano di segnalare modifiche di una destinazione di associazione dati, vedere Cenni preliminari sull'associazione dati.

Stili e modelli sono due degli scenari principali che giustificano l'utilizzo delle proprietà di dipendenza. Gli stili sono particolarmente utili per l'impostazione di proprietà che definiscono l'interfaccia utente dell'applicazione. In genere vengono definiti come risorse in XAML e interagiscono con il sistema di proprietà in quanto di solito contengono metodi di impostazione per proprietà particolari, nonché "trigger" che modificano un valore della proprietà in base al valore in tempo reale per un'altra proprietà.

Nell'esempio seguente viene creato uno stile molto semplice (definito all'interno di un dizionario Resources, non visualizzato) che viene successivamente applicato direttamente alla proprietà Style di un oggetto Button. Il metodo di impostazione dello stile imposta la proprietà Background di un oggetto Button a cui è stato applicato uno stile sul colore verde.

<Style x:Key="GreenButtonStyle">
  <Setter Property="Control.Background" Value="Green"/>
</Style>

<Button Style="{StaticResource GreenButtonStyle}">I am green!</Button>

Per ulteriori informazioni, vedere Applicazione di stili e modelli.

Alle proprietà di dipendenza è possibile aggiungere un'animazione. Quando un'animazione viene applicata ed è in esecuzione, il valore a cui è stata aggiunta un'animazione opera a un livello di precedenza superiore rispetto a qualsiasi altro valore (ad esempio un valore locale) di cui la proprietà dispone.

Nell'esempio seguente viene aggiunta un'animazione all'oggetto Background in una proprietà Button. Tecnicamente, all'oggetto Background viene aggiunta un'animazione utilizzando la sintassi per elementi della proprietà per specificare un oggetto SolidColorBrush vuoto come oggetto Background, quindi la proprietà Color di quell'oggetto SolidColorBrush è la proprietà a cui viene aggiunta direttamente l'animazione.

<Button>I am animated
  <Button.Background>
    <SolidColorBrush x:Name="AnimBrush"/>
  </Button.Background>
  <Button.Triggers>
    <EventTrigger RoutedEvent="Button.Loaded">
      <BeginStoryboard>
        <Storyboard>
          <ColorAnimation
            Storyboard.TargetName="AnimBrush" 
            Storyboard.TargetProperty="(SolidColorBrush.Color)"
            From="Red" To="Green" Duration="0:0:5" 
            AutoReverse="True" RepeatBehavior="Forever" />
        </Storyboard>
      </BeginStoryboard>
    </EventTrigger>
  </Button.Triggers>
</Button>

Per ulteriori informazioni sull'animazione di proprietà, vedere Cenni preliminari sull'animazione e Cenni preliminari sugli storyboard.

È possibile modificare determinati comportamenti di una proprietà di dipendenza eseguendo l'override dei metadati per quella proprietà, quando si deriva dalla classe che registra originariamente la proprietà di dipendenza. L'esecuzione dell'override dei metadati si basa sull'identificatore DependencyProperty. L'esecuzione dell'override dei metadati non richiede una nuova implementazione della proprietà. La modifica dei metadati viene gestita in modo nativo dal sistema di proprietà; ogni classe contiene, potenzialmente, i metadati specifici per tutte le proprietà ereditate dalle classi base, in base al tipo.

Nell'esempio seguente viene eseguito l'override dei metadati per una proprietà di dipendenza DefaultStyleKey. L'esecuzione dell'override dei metadati di questa particolare proprietà di dipendenza fa parte di un modello di implementazione che consente di creare controlli che possono utilizzare stili predefiniti dai temi.

public class SpinnerControl : ItemsControl
{
    static SpinnerControl()
    {
        DefaultStyleKeyProperty.OverrideMetadata(
            typeof(SpinnerControl), 
            new FrameworkPropertyMetadata(typeof(SpinnerControl))
        );
    }
}

Per ulteriori informazioni sull'override o su come ottenere i metadati delle proprietà, vedere Metadati della proprietà di dipendenza.

Un elemento può ereditare il valore di una proprietà di dipendenza dal relativo elemento padre nella struttura ad albero.

Nota:

Il comportamento dell'ereditarietà del valore della proprietà non viene attivato a livello globale per tutte le proprietà di dipendenza, poiché il tempo di calcolo per l'ereditarietà influisce negativamente sulle prestazioni. In genere, l'ereditarietà del valore della proprietà viene attivata solo per le proprietà in cui uno scenario particolare suggerisce che tale ereditarietà è appropriata. La possibilità di ereditare di una proprietà di dipendenza può essere determinata consultando la sezione relativa alle informazioni sulle proprietà di dipendenza per una determinata proprietà di dipendenza, nel riferimento SDK.

Nell'esempio seguente viene descritta un'associazione e impostata la proprietà DataContext che specifica l'origine dell'associazione, non illustrata nell'esempio di associazione precedente. Il valore della proprietà DataContext viene ereditato, pertanto qualsiasi associazione successiva negli elementi figlio non deve rispettare l'origine specificata come oggetto DataContext nell'elemento StackPanel padre.

<StackPanel Canvas.Top="50" DataContext="{Binding Source={StaticResource XmlTeamsSource}}">
  <Button Content="{Binding XPath=Team/@TeamName}"/>
</StackPanel>

Per ulteriori informazioni, vedere Ereditarietà del valore della proprietà.

Un controllo personalizzato con proprietà implementate come proprietà di dipendenza riceverà un supporto Progettazione Windows Presentation Foundation (WPF) per Visual Studio appropriato. Un esempio è rappresentato dalla capacità di modificare proprietà di dipendenza dirette e associate tramite la finestra Proprietà. Per ulteriori informazioni, vedere Cenni preliminari sulla modifica di controlli.

In genere, non si desidera che gli stili vengano sempre applicati e che nascondano persino un valore impostato localmente di un singolo elemento (altrimenti sarebbe molto difficile utilizzare gli stili o gli elementi in generale). Pertanto, i valori che provengono dagli stili operano a un livello di precedenza inferiore rispetto a un valore impostato localmente. Per un elenco più completo delle proprietà di dipendenza e per la possibile provenienza di un valore effettivo di una proprietà di dipendenza, vedere Precedenza del valore della proprietà di dipendenza.

Nota:

Molte proprietà definite negli elementi WPF non sono proprietà di dipendenza. In generale, le proprietà vengono implementate come proprietà di dipendenza solo quando è necessario supportare almeno uno degli scenari attivati dal sistema di proprietà: associazione dati, applicazione degli stili, animazione, supporto del valore predefinito, ereditarietà, proprietà associate o annullamento della convalida.