Panoramica sulle proprietà di dipendenzaDependency properties overview

Windows Presentation Foundation (WPF) include un set di servizi che è possibile usare per estendere la funzionalità di una proprietà di un tipo.Windows Presentation Foundation (WPF) provides a set of services that can be used to extend the functionality of a type's property. In genere, questi servizi vengono definiti collettivamente come sistema di proprietà WPF.Collectively, these services are typically referred to as the WPF property system. Una proprietà supportata dal sistema di proprietà WPF è nota come proprietà di dipendenza.A property that is backed by the WPF property system is known as a dependency property. Questa panoramica descrive il sistema di proprietà WPF e le funzionalità di una proprietà di dipendenza.This overview describes the WPF property system and the capabilities of a dependency property. Viene anche spiegato come usare le proprietà di dipendenza esistenti in XAML e nel codice.This includes how to use existing dependency properties in XAML and in code. In questa panoramica vengono anche illustrati aspetti specifici delle proprietà di dipendenza, ad esempio i metadati delle proprietà di dipendenza e la creazione di una proprietà di dipendenza in una classe personalizzata.This overview also introduces specialized aspects of dependency properties, such as dependency property metadata, and how to create your own dependency property in a custom class.

PrerequisitesPrerequisites

In questo argomento si presuppone che l'utente disponga di una conoscenza di base del sistema di tipi .NET e della programmazione orientata a oggetti.This topic assumes that you have some basic knowledge of the .NET type system and object-oriented programming. Per seguire gli esempi illustrati in questo argomento, è anche necessario conoscere XAML e saper scrivere applicazioni WPF.In order to follow the examples in this topic, you should also understand XAML and know how to write WPF applications. Per altre informazioni, vedere Procedura dettagliata: La prima applicazione desktop WPF.For more information, see Walkthrough: My first WPF desktop application.

Proprietà di dipendenza e proprietà CLRDependency properties and CLR properties

In WPF le proprietà vengono generalmente esposte come proprietà .NET standard.In WPF, properties are typically exposed as standard .NET properties. A un livello di base, si potrebbe interagire direttamente con queste proprietà senza sapere che vengono implementate come una proprietà di dipendenza.At a basic level, you could interact with these properties directly and never know that they are implemented as a dependency property. Tuttavia, è necessario acquisire familiarità con alcune o tutte le funzionalità del sistema di proprietà WPF, in modo da poterle sfruttare.However, you should become familiar with some or all of the features of the WPF property system, so that you can take advantage of these features.

Lo scopo delle proprietà di dipendenza consiste nel fornire un modo per calcolare il valore di una proprietà in base al valore di altri input.The purpose of dependency properties is to provide a way to compute the value of a property based on the value of other inputs. Questi potrebbero includere proprietà del sistema, quali temi e preferenze dell'utente, meccanismi di determinazione della proprietà JIT, ad esempio data binding dati e animazioni o storyboard, modelli multiuso, quali risorse e stili oppure valori noti tramite relazioni padre-figlio con altri elementi dell'albero degli elementi.These other inputs might include system properties such as themes and user preference, just-in-time property determination mechanisms such as data binding and animations/storyboards, multiple-use templates such as resources and styles, or values known through parent-child relationships with other elements in the element tree. Inoltre, una proprietà di dipendenza può essere implementata per fornire una convalida autonoma, valori predefiniti, callback per il monitoraggio delle modifiche di altre proprietà, nonché un sistema che può assegnare forzatamente valori della proprietà in base a potenziali informazioni di runtime.In addition, a dependency property can be implemented to provide self-contained validation, default values, callbacks that monitor changes to other properties, and a system that can coerce property values based on potentially runtime information. Le classi derivate possono anche modificare alcune caratteristiche specifiche di una proprietà esistente, eseguendo l'override dei metadati della proprietà di dipendenza invece dell'override dell'implementazione effettiva delle proprietà esistenti oppure della creazione di nuove proprietà.Derived classes can also change some specific characteristics of an existing property by overriding dependency property metadata, rather than overriding the actual implementation of existing properties or creating new properties.

Nel riferimento SDK, è possibile identificare la proprietà di dipendenza grazie alla sezione Informazioni sulle proprietà di dipendenza, presente nella pagina di riferimento gestita per quella proprietà.In the SDK reference, you can identify which property is a dependency property by the presence of the Dependency Property Information section on the managed reference page for that property. Nella sezione sono inclusi un collegamento al campo dell'identificatore DependencyProperty per quella proprietà di dipendenza e un elenco delle opzioni dei metadati impostati per quella proprietà, informazioni sull'override per classe e altri dettagli.The Dependency Property Information section includes a link to the DependencyProperty identifier field for that dependency property, and also includes a list of the metadata options that are set for that property, per-class override information, and other details.

Proprietà di dipendenza che supportano le proprietà CLRDependency properties back CLR properties

Le proprietà di dipendenza e il sistema di proprietà WPF estendono le funzionalità della proprietà fornendo un tipo che supporta una proprietà, come implementazione alternativa al modello standard di supporto della proprietà con un campo privato.Dependency properties and the WPF property system extend property functionality by providing a type that backs a property, as an alternative implementation to the standard pattern of backing the property with a private field. Il nome del tipo è DependencyProperty.The name of this type is DependencyProperty. L'altro tipo importante che definisce il sistema di proprietà WPF è DependencyObject.The other important type that defines the WPF property system is DependencyObject. DependencyObject definisce la classe di base che può essere registrata ed essere proprietaria di una proprietà di dipendenza.DependencyObject defines the base class that can register and own a dependency property.

Di seguito è elencata la terminologia usata con le proprietà di dipendenza:The following lists the terminology that is used with dependency properties:

  • Proprietà di dipendenza: proprietà supportata da un oggetto DependencyProperty.Dependency property: A property that is backed by a DependencyProperty.

  • Identificatore della proprietà di dipendenza: istanza di DependencyProperty, ottenuta come valore restituito quando si registra una proprietà di dipendenza e quindi archiviata come membro statico di una classe.Dependency property identifier: A DependencyProperty instance, which is obtained as a return value when registering a dependency property, and then stored as a static member of a class. Questo identificatore viene usato come parametro per molte API che interagiscono con il sistema di proprietà WPF.This identifier is used as a parameter for many of the APIs that interact with the WPF property system.

  • "Wrapper" CLR: le implementazioni effetti Get e Set per la proprietà.CLR "wrapper": The actual get and set implementations for the property. Queste implementazioni includono l'identificatore della proprietà di dipendenza usandolo nelle chiamate GetValue e SetValue, in modo da fornire il supporto per la proprietà tramite il sistema di proprietà WPF.These implementations incorporate the dependency property identifier by using it in the GetValue and SetValue calls, thus providing the backing for the property using the WPF property system.

L'esempio seguente definisce la proprietà di dipendenza IsSpinning e mostra la relazione tra l'identificatore DependencyProperty e la proprietà supportata.The following example defines the IsSpinning dependency property, and shows the relationship of the DependencyProperty identifier to the property that it backs.

public static readonly DependencyProperty IsSpinningProperty = 
    DependencyProperty.Register(
    "IsSpinning", typeof(Boolean),
    typeof(MyCode)
    );
public bool IsSpinning
{
    get { return (bool)GetValue(IsSpinningProperty); }
    set { SetValue(IsSpinningProperty, value); }
}
Public Shared ReadOnly IsSpinningProperty As DependencyProperty =
    DependencyProperty.Register("IsSpinning",
                                GetType(Boolean),
                                GetType(MyCode))

Public Property IsSpinning() As Boolean
    Get
        Return CBool(GetValue(IsSpinningProperty))
    End Get
    Set(ByVal value As Boolean)
        SetValue(IsSpinningProperty, value)
    End Set
End Property

La convenzione di denominazione della proprietà e del relativo campo DependencyProperty di supporto è importante.The naming convention of the property and its backing DependencyProperty field is important. Il nome del campo è sempre il nome della proprietà al quale viene aggiunto il suffisso Property.The name of the field is always the name of the property, with the suffix Property appended. Per altre informazioni su questa convenzione e i relativi motivi, vedere Proprietà di dipendenza personalizzate.For more information about this convention and the reasons for it, see Custom Dependency Properties.

Impostazione dei valori delle proprietàSetting property values

È possibile impostare le proprietà nel codice o in XAML.You can set properties either in code or in XAML.

Impostazione dei valori delle proprietà in XAMLSetting property values in XAML

L'esempio di XAML seguente specifica il colore di sfondo rosso per un pulsante.The following XAML example specifies the background color of a button as red. Questo esempio illustra un caso in cui il valore di stringa semplice per un attributo XAML viene convertito dal parser XAML WPF in un tipo WPF (Color tramite SolidColorBrush) nel codice generato.This example illustrates a case where the simple string value for a XAML attribute is type-converted by the WPF XAML parser into a WPF type (a Color, by way of a SolidColorBrush) in the generated code.

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

XAML supporta diverse sintassi per l'impostazione delle proprietà.XAML supports a variety of syntax forms for setting properties. La sintassi da usare per una proprietà particolare dipende dal tipo di valore usato da una proprietà e da altri fattori, quali la presenza di un convertitore dei tipi.Which syntax to use for a particular property will depend on the value type that a property uses, as well as other factors such as the presence of a type converter. Per altre informazioni sulla sintassi XAML per l'impostazione di proprietà, vedere Cenni preliminari su XAML (WPF) e Descrizione dettagliata della sintassi XAML.For more information on XAML syntax for property setting, see XAML Overview (WPF) and XAML Syntax In Detail.

Come esempio di sintassi senza attributi, nell'esempio di XAML seguente viene illustrato lo sfondo di un altro pulsante.As an example of non-attribute syntax, the following XAML example shows another button background. 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 annidato.This time rather than setting a simple solid color, the background is set to an image, with an element representing that image and the source of that image specified as an attribute of the nested element. Si tratta di un esempio di sintassi per gli elementi proprietà.This is an example of property element syntax.

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

Impostazione delle proprietà nel codiceSetting properties in code

L'impostazione dei valori delle proprietà di dipendenza nel codice è in genere semplicemente una chiamata all'implementazione del set esposta dal "wrapper" CLR.Setting dependency property values in code is typically just a call to the set implementation exposed by the CLR "wrapper".

Button myButton = new Button();
myButton.Width = 200.0;
Dim myButton As New Button()
myButton.Width = 200.0

Anche il recupero di un valore della proprietà prevede sostanzialmente una chiamata all'implementazione del "wrapper" Get:Getting a property value is also essentially a call to the get "wrapper" implementation:

double whatWidth;
whatWidth = myButton.Width;
Dim whatWidth As Double
whatWidth = myButton.Width

È anche possibile chiamare le API del sistema di proprietà GetValue e SetValue direttamente.You can also call the property system APIs GetValue and SetValue directly. Questa operazione non è in genere necessaria se si usano proprietà esistenti (i wrapper sono più pratici e offrono una migliore esposizione della proprietà per gli strumenti di sviluppo), ma la chiamata diretta delle API è appropriata per determinati scenari.This is not typically necessary if you are using existing properties (the wrappers are more convenient, and provide better exposure of the property for developer tools), but calling the APIs directly is appropriate for certain scenarios.

È anche possibile impostare le proprietà in XAML e successivamente accedervi nel codice tramite code-behind.Properties can be also set in XAML and then accessed later in code, through code-behind. Per informazioni dettagliate, vedere Code-behind e XAML in WPF.For details, see Code-Behind and XAML in WPF.

Funzionalità offerte da una proprietà di dipendenzaProperty functionality provided by a dependency property

Una proprietà di dipendenza fornisce funzionalità che consentono di estendere la funzionalità di una proprietà, rispetto a una proprietà supportata da un campo.A dependency property provides functionality that extends the functionality of a property as opposed to a property that is backed by a field. Spesso tale funzionalità rappresenta o supporta una delle funzionalità specifiche seguenti:Often, such functionality represents or supports one of the following specific features:

RisorseResources

Un valore della proprietà di dipendenza può essere impostato facendo riferimento a una risorsa.A dependency property value can be set by referencing a resource. Le risorse vengono in genere specificate come valore della proprietà Resources di un elemento radice della pagina o dell'applicazione (questi percorsi consentono un accesso più semplice alla risorsa).Resources are typically specified as the Resources property value of a page root element, or of the application (these locations enable the most convenient access to the resource). L'esempio seguente illustra come definire una risorsa SolidColorBrush.The following example shows how to define a SolidColorBrush resource.

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

Una volta definita, è possibile fare riferimento alla risorsa e usarla per fornire un valore della proprietà:Once the resource is defined, you can reference the resource and use it to provide a property value:

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

A questa risorsa particolare viene fatto riferimento come estensione del markup DynamicResource. In XAML WPF è possibile usare un riferimento di risorsa statica o dinamica.This particular resource is referenced as a DynamicResource Markup Extension (in WPF XAML, you can use either a static or dynamic resource reference). Per usare 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 specifico del riferimento di risorsa dinamica.To use a dynamic resource reference, you must be setting to a dependency property, so it is specifically the dynamic resource reference usage that is enabled by the WPF property system. Per altre informazioni, vedere Risorse XAML.For more information, see XAML Resources.

Nota

Le risorse vengono considerate come valore locale, per cui se si imposta un altro valore locale, il riferimento di risorsa sarà eliminato.Resources are treated as a local value, which means that if you set another local value, you will eliminate the resource reference. Per altre informazioni, vedere Precedenza del valore della proprietà di dipendenza.For more information, see Dependency Property Value Precedence.

Associazione datiData binding

Una proprietà di dipendenza può fare riferimento a un valore tramite il data binding,A dependency property can reference a value through data binding. che funziona tramite una sintassi per estensione di markup specifica in XAML o l'oggetto Binding nel codice.Data binding works through a specific markup extension syntax in XAML, or the Binding object in code. Con il data binding, la determinazione del valore della proprietà finale viene rinviata fino alla fase di esecuzione, momento in cui il valore viene ottenuto da un'origine dati.With data binding, the final property value determination is deferred until run time, at which time the value is obtained from a data source.

L'esempio seguente imposta la proprietà Content per un oggetto Button tramite un'associazione dichiarata in XAML.The following example sets the Content property for a Button, using a binding declared in XAML. L'associazione usa un contesto dei dati ereditato e un'origine dati XmlDataProvider (non illustrata).The binding uses an inherited data context and an XmlDataProvider data source (not shown). L'associazione stessa specifica la proprietà di origine desiderata mediante l'oggetto XPath all'interno dell'origine dati.The binding itself specifies the desired source property by XPath within the data source.

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

Nota

I binding vengono considerati come valore locale, per cui se si imposta un altro valore locale, il binding verrà eliminato.Bindings are treated as a local value, which means that if you set another local value, you will eliminate the binding. Per altri dettagli, vedere Precedenza del valore della proprietà di dipendenza.For details, see Dependency Property Value Precedence.

Le proprietà di dipendenza, o la classe DependencyObject, non supportano INotifyPropertyChanged in modo nativo per la generazione di notifiche delle modifiche nel valore della proprietà di origine DependencyObject per le operazioni di associazione di dati.Dependency properties, or the DependencyObject class, do not natively support INotifyPropertyChanged for purposes of producing notifications of changes in DependencyObject source property value for data binding operations. Per altre informazioni su come creare proprietà da usare nel data binding, che consentano di segnalare modifiche di una destinazione di data binding, vedere Panoramica sul data binding.For more information on how to create properties for use in data binding that can report changes to a data binding target, see Data Binding Overview.

StiliStyles

Stili e modelli sono due degli scenari principali che giustificano l'uso delle proprietà di dipendenza.Styles and templates are two of the chief motivating scenarios for using dependency properties. Gli stili sono particolarmente utili per l'impostazione di proprietà che definiscono l'interfaccia utenteuser interface (UI) dell'applicazione.Styles are particularly useful for setting properties that define application interfaccia utenteuser interface (UI). In genere gli stili vengono definiti come risorse in XAMLStyles are typically defined as resources in XAML. e interagiscono con il sistema di proprietà in quanto di solito contengono "setter" per proprietà particolari, nonché "trigger" che modificano un valore della proprietà in base al valore in tempo reale per un'altra proprietà.Styles interact with the property system because they typically contain "setters" for particular properties, as well as "triggers" that change a property value based on the real-time value for another property.

L'esempio seguente crea uno stile molto semplice (definito all'interno di un dizionario Resources, non illustrato), e quindi lo applica direttamente alla proprietà Style di un oggetto Button.The following example creates a very simple style (which would be defined inside a Resources dictionary, not shown), then applies that style directly to the Style property for a Button. Il setter all'interno dello stile imposta la proprietà Background di un oggetto Button con stile su verde.The setter within the style sets the Background property for a styled Button to green.

<Style x:Key="GreenButtonStyle">
  <Setter Property="Control.Background" Value="Green"/>
</Style>
<Button Style="{StaticResource GreenButtonStyle}">I am green!</Button>

Per altre informazioni, vedere Applicazione di stili e modelli.For more information, see Styling and Templating.

AnimationsAnimations

Alle proprietà di dipendenza è possibile aggiungere un'animazione.Dependency properties can be animated. 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) della proprietà.When an animation is applied and is running, the animated value operates at a higher precedence than any value (such as a local value) that the property otherwise has.

L'esempio seguente aggiunge un'animazione alla proprietà Background di un oggetto Button. Tecnicamente, l'animazione viene aggiunta alla proprietà Background tramite la sintassi degli elementi proprietà per specificare un SolidColorBrush vuoto come Background e quindi la proprietà Color dell'oggetto SolidColorBrush è la proprietà a cui viene direttamente applicata l'animazione.The following example animates the Background on a Button property (technically, the Background is animated by using property element syntax to specify a blank SolidColorBrush as the Background, then the Color property of that SolidColorBrush is the property that is directly animated).

<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 altre informazioni sull'animazione di proprietà, vedere Cenni preliminari sull'animazione e Cenni preliminari sugli storyboard.For more information on animating properties, see Animation Overview and Storyboards Overview.

Override dei metadatiMetadata overrides

È 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.You can change certain behaviors of a dependency property by overriding the metadata for that property when you derive from the class that originally registers the dependency property. L'override dei metadati si basa sull'identificatore DependencyProperty.Overriding metadata relies on the DependencyProperty identifier. L'override dei metadati non richiede una nuova implementazione della proprietà.Overriding metadata does not require re-implementing the property. 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 di base, in base al tipo.The metadata change is handled natively by the property system; each class potentially holds individual metadata for all properties that are inherited from base classes, on a per-type basis.

L'esempio seguente esegue l'override dei metadati per una proprietà di dipendenza DefaultStyleKey.The following example overrides metadata for a dependency property DefaultStyleKey. L'override dei metadati di questa particolare proprietà di dipendenza fa parte di un modello di implementazione che consente di creare controlli che possono usare stili predefiniti dai temi.Overriding this particular dependency property metadata is part of an implementation pattern that creates controls that can use default styles from themes.

public class SpinnerControl : ItemsControl
{
    static SpinnerControl()
    {
        DefaultStyleKeyProperty.OverrideMetadata(
            typeof(SpinnerControl), 
            new FrameworkPropertyMetadata(typeof(SpinnerControl))
        );
    }
}
Public Class SpinnerControl
    Inherits ItemsControl
    Shared Sub New()
        DefaultStyleKeyProperty.OverrideMetadata(GetType(SpinnerControl), New FrameworkPropertyMetadata(GetType(SpinnerControl)))
    End Sub
End Class

Per altre informazioni sull'override dei metadati delle proprietà o su come ottenere i metadati delle proprietà, vedere Metadati delle proprietà di dipendenza.For more information about overriding or obtaining property metadata, see Dependency Property Metadata.

Ereditarietà del valore della proprietàProperty value inheritance

Un elemento può ereditare il valore di una proprietà di dipendenza dal relativo elemento padre nell'albero di oggetti.An element can inherit the value of a dependency property from its parent in the object tree.

Nota

Il comportamento dell'ereditarietà del valore della proprietà non viene abilitato a livello globale per tutte le proprietà di dipendenza, poiché il tempo di calcolo per l'ereditarietà influisce negativamente sulle prestazioni.Property value inheritance behavior is not globally enabled for all dependency properties, because the calculation time for inheritance does have some performance impact. In genere, l'ereditarietà del valore della proprietà viene abilitata solo per le proprietà in cui uno scenario particolare suggerisce che tale ereditarietà è appropriata.Property value inheritance is typically only enabled for properties where a particular scenario suggests that property value inheritance is appropriate. La possibilità di ereditare di una proprietà di dipendenza può essere determinata consultando la sezione Informazioni proprietà di dipendenza per una determinata proprietà di dipendenza, nel riferimento SDK.You can determine whether a dependency property inherits by looking at the Dependency Property Information section for that dependency property in the SDK reference.

L'esempio seguente descrive un'associazione e imposta la proprietà DataContext che specifica l'origine dell'associazione, non illustrata nell'esempio di associazione precedente.The following example shows a binding, and sets the DataContext property that specifies the source of the binding, which was not shown in the earlier binding example. Eventuali associazioni successive in oggetti figlio non devono necessariamente specificare l'origine, ma possono usare il valore ereditato da DataContext nell'oggetto StackPanel padre.Any subsequent bindings in child objects do not need to specify the source, they can use the inherited value from DataContext in the parent StackPanel object. In alternativa, un oggetto figlio può invece scegliere di specificare direttamente il proprio DataContext o un Source in Binding e non usare deliberatamente il valore ereditato per il contesto dei dati delle sue associazioni.(Alternatively, a child object could instead choose to directly specify its own DataContext or a Source in the Binding, and to deliberately not use the inherited value for data context of its bindings.)

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

Per altre informazioni, vedere Ereditarietà del valore della proprietà.For more information, see Property Value Inheritance.

Integrazione di WPF DesignerWPF designer integration

Un controllo personalizzato con proprietà implementate come proprietà di dipendenza riceverà la finestra di progettazione WPF appropriata per il supporto di Visual Studio.A custom control with properties that are implemented as dependency properties will receive appropriate WPF Designer for Visual Studio support. Un esempio è rappresentato dalla capacità di modificare proprietà di dipendenza dirette e associate tramite la finestra Proprietà.One example is the ability to edit direct and attached dependency properties with the Properties window. Per altre informazioni, vedere Cenni preliminari sulla modifica di controlli.For more information, see Control Authoring Overview.

Precedenza del valore della proprietà di dipendenzaDependency property value precedence

Quando si ottiene il valore di una proprietà di dipendenza, si ottiene potenzialmente un valore impostato per tale proprietà tramite uno qualsiasi degli altri input basati su proprietà che fanno parte del sistema di proprietà WPF.When you get the value of a dependency property, you are potentially obtaining a value that was set on that property through any one of the other property-based inputs that participate in the WPF property system. La precedenza del valore della proprietà di dipendenza consente interazioni prevedibili per un'ampia gamma di scenari relativi al modo in cui le proprietà ottengono i rispettivi valori.Dependency property value precedence exists so that a variety of scenarios for how properties obtain their values can interact in a predictable way.

Si osservi l'esempio riportato di seguito.Consider the following example. L'esempio include uno stile che si applica a tutti i pulsanti e alle loro proprietà Background, ma specifica anche un pulsante con un valore Background impostato localmente.The example includes a style that applies to all buttons and their Background properties, but then also specifies one button with a locally set Background value.

Nota

Nella documentazione SDK i termini "valore locale" o "valore impostato localmente" vengono usati talvolta per la descrizione delle proprietà di dipendenza.The SDK documentation uses the terms "local value" or "locally set value" occasionally when discussing dependency properties. Un valore impostato localmente è un valore di proprietà che viene impostato direttamente in un'istanza di oggetto nel codice o come attributo di un elemento in XAML.A locally set value is a property value that is set directly on an object instance in code, or as an attribute on an element in XAML.

In teoria, per il primo pulsante la proprietà viene impostata due volte, ma viene applicato un solo valore, quello con la precedenza più alta.In principle, for the first button, the property is set twice, but only one value applies: the value with the highest precedence. Un valore impostato localmente ha la massima precedenza (eccetto per un'animazione in esecuzione; tuttavia, in questo esempio non viene applicata nessuna animazione), pertanto per lo sfondo del primo pulsante viene usato il valore impostato localmente invece del valore del setter di stile.A locally set value has the highest precedence (except for a running animation, but no animation applies in this example) and thus the locally set value is used instead of the style setter value for the background on the first button. Il secondo pulsante non ha un valore locale (e nessun altro valore con precedenza più alta rispetto a un setter di stile), pertanto lo sfondo di quel pulsante proviene dal setter di stile.The second button has no local value (and no other value with higher precedence than a style setter) and thus the background in that button comes from the style setter.

<StackPanel>
  <StackPanel.Resources>
    <Style x:Key="{x:Type Button}" TargetType="{x:Type Button}">
     <Setter Property="Background" Value="Red"/>
    </Style>
  </StackPanel.Resources>
  <Button Background="Green">I am NOT red!</Button>
  <Button>I am styled red</Button>
</StackPanel>

Motivi dell'esistenza della precedenza delle proprietà di dipendenzaWhy does dependency property precedence exist?

In genere, non si vuole che gli stili vengano sempre applicati e che nascondano persino un valore impostato localmente di un singolo elemento, altrimenti sarebbe molto difficile usare gli stili o gli elementi in generale.Typically, you would not want styles to always apply and to obscure even a locally set value of an individual element (otherwise, it would be very difficult to use either styles or elements in general). Per questo motivo, i valori che provengono dagli stili operano a un livello di precedenza inferiore rispetto a un valore impostato localmente.Therefore, the values that come from styles operate at a lower precedent than a locally set value. Per un elenco più completo delle proprietà di dipendenza e informazioni sulla possibile provenienza di un valore effettivo di una proprietà di dipendenza, vedere Precedenza del valore della proprietà di dipendenza.For a more thorough listing of dependency properties and where a dependency property effective value might come from, see Dependency Property Value Precedence.

Nota

Molte proprietà definite negli elementi WPF non sono proprietà di dipendenza.There are a number of properties defined on WPF elements that are not dependency properties. In generale, le proprietà vengono implementate come proprietà di dipendenza solo quando è necessario supportare almeno uno degli scenari abilitati dal sistema di proprietà: data binding, applicazione degli stili, animazione, supporto del valore predefinito, ereditarietà, proprietà associate o invalidamento.By and large, properties were implemented as dependency properties only when there were needs to support at least one of the scenarios enabled by the property system: data binding, styling, animation, default value support, inheritance, attached properties, or invalidation.

Altre informazioni sulle proprietà di dipendenzaLearning more about dependency properties

  • Una proprietà associata è un tipo di proprietà che supporta una sintassi specializzata in XAML.An attached property is a type of property that supports a specialized syntax in XAML. Una proprietà associata spesso non ha una corrispondenza 1:1 con una proprietà Common Language Runtime (CLR) e non è necessariamente una proprietà di dipendenza.An attached property often does not have a 1:1 correspondence with a common language runtime (CLR) property, and is not necessarily a dependency property. Lo scopo tipico di una proprietà associata consiste nel consentire agli elementi figlio di segnalare i valori della proprietà a un elemento padre, anche se quest'ultimo e l'elemento figlio non possiedono tale proprietà, come parte degli elenchi dei membri della classe.The typical purpose of a attached property is to allow child elements to report property values to a parent element, even if the parent element and child element do not both possess that property as part of the class members listings. Uno scenario principale è l'abilitazione di elementi figlio per informare l'elemento padre di come devono essere presentati in Interfaccia utenteUI. Per un esempio, vedere Dock o Left.One primary scenario is to enable child elements to inform the parent how they should be presented in Interfaccia utenteUI; for an example, see Dock or Left. Per informazioni dettagliate, vedere Cenni preliminari sulle proprietà associate.For details, see Attached Properties Overview.

  • Gli sviluppatori di componenti o di applicazioni possono decidere di creare una proprietà di dipendenza personalizzata al fine di abilitare funzionalità quali il data binding o il supporto degli stili oppure per il supporto dell'invalidamento e della coercizione del valore.Component developers or application developers may wish to create their own dependency property, in order to enable capabilities such as data binding or styles support, or for invalidation and value coercion support. Per informazioni dettagliate, vedere Proprietà di dipendenza personalizzate.For details, see Custom Dependency Properties.

  • Generalmente, le proprietà di dipendenza devono essere considerate come proprietà pubbliche, accessibili o almeno individuabili da parte di qualsiasi chiamante con accesso a un'istanza.Dependency properties should generally be considered to be public properties, accessible or at least discoverable by any caller that has access to an instance. Per altre informazioni, vedere Sicurezza delle proprietà di dipendenza.For more information, see Dependency Property Security.

Vedere ancheSee also