Cenni preliminari sulle risorse XAML (WPF .NET)Overview of XAML resources (WPF .NET)

Una risorsa è un oggetto che può essere riutilizzato in posizioni diverse nell'app.A resource is an object that can be reused in different places in your app. Sono esempi di risorse pennelli e stili.Examples of resources include brushes and styles. In questa panoramica viene descritto come usare le risorse in Extensible Application Markup Language (XAML).This overview describes how to use resources in Extensible Application Markup Language (XAML). È anche possibile creare e accedere alle risorse usando il codice.You can also create and access resources by using code.

Nota

Le risorse XAML descritte in questo articolo sono diverse dalle risorse dell'app , che sono in genere file aggiunti a un'app, ad esempio contenuto, dati o file incorporati.XAML resources described in this article are different from app resources which are generally files added to an app, such as content, data, or embedded files.

Importante

La documentazione della Guida per desktop per .NET 5 (e .NET Core) è in fase di creazione.The Desktop Guide documentation for .NET 5 (and .NET Core) is under construction.

Uso delle risorse in XAMLUsing resources in XAML

Nell'esempio seguente viene definito un SolidColorBrush come risorsa nell'elemento radice di una pagina.The following example defines a SolidColorBrush as a resource on the root element of a page. L'esempio fa quindi riferimento alla risorsa e la usa per impostare le proprietà di diversi elementi figlio, inclusi un oggetto Ellipse , un oggetto TextBlock e un oggetto Button .The example then references the resource and uses it to set properties of several child elements, including an Ellipse, a TextBlock, and a Button.

<Page Name="root"
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
>
  <Page.Resources>
    <SolidColorBrush x:Key="MyBrush" Color="Gold"/>
    <Style TargetType="Border" x:Key="PageBackground">
      <Setter Property="Background" Value="Blue"/>
    </Style>
    <Style TargetType="TextBlock" x:Key="TitleText">
      <Setter Property="Background" Value="Blue"/>
      <Setter Property="DockPanel.Dock" Value="Top"/>
      <Setter Property="FontSize" Value="18"/>
      <Setter Property="Foreground" Value="#4E87D4"/>
      <Setter Property="FontFamily" Value="Trebuchet MS"/>
      <Setter Property="Margin" Value="0,40,10,10"/>
    </Style>
    <Style TargetType="TextBlock" x:Key="Label">
      <Setter Property="DockPanel.Dock" Value="Right"/>
      <Setter Property="FontSize" Value="8"/>
      <Setter Property="Foreground" Value="{StaticResource MyBrush}"/>
      <Setter Property="FontFamily" Value="Arial"/>
      <Setter Property="FontWeight" Value="Bold"/>
      <Setter Property="Margin" Value="0,3,10,0"/>
    </Style>
  </Page.Resources>
  <StackPanel>
    <Border Style="{StaticResource PageBackground}">
      <DockPanel>
        <TextBlock Style="{StaticResource TitleText}">Title</TextBlock>
        <TextBlock Style="{StaticResource Label}">Label</TextBlock>
        <TextBlock DockPanel.Dock="Top" HorizontalAlignment="Left" FontSize="36" Foreground="{StaticResource MyBrush}" Text="Text" Margin="20" />
        <Button DockPanel.Dock="Top" HorizontalAlignment="Left" Height="30" Background="{StaticResource MyBrush}" Margin="40">Button</Button>
        <Ellipse DockPanel.Dock="Top" HorizontalAlignment="Left" Width="100" Height="100" Fill="{StaticResource MyBrush}" Margin="40" />
      </DockPanel>
    </Border>
  </StackPanel>
</Page>


Ogni elemento a livello di Framework ( FrameworkElement o FrameworkContentElement ) ha una Resources proprietà, che è un ResourceDictionary tipo che contiene le risorse definite.Every framework-level element (FrameworkElement or FrameworkContentElement) has a Resources property, which is a ResourceDictionary type that contains defined resources. È possibile definire le risorse per qualsiasi elemento, ad esempio Button .You can define resources on any element, such as a Button. Tuttavia, le risorse vengono spesso definite nell'elemento radice, che è Page nell'esempio.However, resources are most often defined on the root element, which is Page in the example.

Ogni risorsa in un dizionario risorse deve avere una chiave univoca.Each resource in a resource dictionary must have a unique key. Quando si definiscono le risorse nel markup, si assegna la chiave univoca tramite la direttiva x:Key.When you define resources in markup, you assign the unique key through the x:Key Directive. In genere, la chiave è una stringa. È tuttavia possibile impostare la chiave su altri tipi di oggetto tramite le estensioni di markup appropriate.Typically, the key is a string; however, you can also set it to other object types by using the appropriate markup extensions. Le chiavi non di tipo stringa per le risorse vengono utilizzate da determinate aree di funzionalità in WPF, in particolare per gli stili, le risorse componenti e lo stile dei dati.Non-string keys for resources are used by certain feature areas in WPF, notably for styles, component resources, and data styling.

È possibile usare una risorsa definita con la sintassi dell'estensione di markup della risorsa che specifica il nome della chiave della risorsa.You can use a defined resource with the resource markup extension syntax that specifies the key name of the resource. Ad esempio, usare la risorsa come valore di una proprietà in un altro elemento.For example, use the resource as the value of a property on another element.

<Button Background="{StaticResource MyBrush}"/>
<Ellipse Fill="{StaticResource MyBrush}"/>

Nell'esempio precedente, quando il caricatore XAML elabora il valore {StaticResource MyBrush} per la Background Proprietà in Button , la logica di ricerca delle risorse verifica prima di tutto il dizionario risorse per l' Button elemento.In the preceding example, when the XAML loader processes the value {StaticResource MyBrush} for the Background property on Button, the resource lookup logic first checks the resource dictionary for the Button element. Se Button non dispone di una definizione della chiave di risorsa MyBrush (in questo esempio, la relativa raccolta di risorse è vuota), la ricerca successiva controlla l'elemento padre di Button , ovvero Page .If Button doesn't have a definition of the resource key MyBrush (in that example it doesn't; its resource collection is empty), the lookup next checks the parent element of Button, which is Page. Se si definisce una risorsa sull' Page elemento radice, tutti gli elementi nell'albero logico di Page possono accedervi.If you define a resource on the Page root element, all the elements in the logical tree of the Page can access it. È anche possibile riutilizzare la stessa risorsa per impostare il valore di qualsiasi proprietà che accetti lo stesso tipo rappresentato dalla risorsa.And you can reuse the same resource for setting the value of any property that accepts the same type that the resource represents. Nell'esempio precedente, la stessa MyBrush risorsa imposta due proprietà diverse: la proprietà Background di un oggetto Button e la proprietà Fill di un oggetto Rectangle .In the previous example, the same MyBrush resource sets two different properties: the Background of a Button, and the Fill of a Rectangle.

Risorse statiche e dinamicheStatic and dynamic resources

È possibile fare riferimento a una risorsa come statica o dinamica.A resource can be referenced as either static or dynamic. I riferimenti vengono creati usando l' estensione di markup StaticResource o l' estensione di markup DynamicResource.References are created by using either the StaticResource Markup Extension or the DynamicResource Markup Extension. Un'estensione di markup è una funzionalità XAML che consente di specificare un riferimento a un oggetto mediante l'estensione di markup che elabora la stringa dell'attributo e restituisce l'oggetto a un caricatore XAML.A markup extension is a XAML feature that lets you specify an object reference by having the markup extension process the attribute string and return the object to a XAML loader. Per altre informazioni sul comportamento dell'estensione di markup, vedere estensioni di markup e XAML WPF.For more information about markup extension behavior, see Markup Extensions and WPF XAML.

Quando si usa un'estensione di markup, in genere si forniscono uno o più parametri in formato stringa elaborati da un'estensione di markup particolare.When you use a markup extension, you typically provide one or more parameters in string form that are processed by that particular markup extension. L' estensione di markup StaticResource elabora una chiave cercando il valore della chiave in tutti i dizionari risorse disponibili.The StaticResource Markup Extension processes a key by looking up the value for that key in all available resource dictionaries. L'elaborazione viene eseguita durante il caricamento, ovvero quando il processo di caricamento deve assegnare il valore della proprietà.Processing happens during load, which is when the loading process needs to assign the property value. L' estensione di markup DynamicResource elabora invece una chiave creando un'espressione e tale espressione rimane non valutata fino a quando l'app non viene eseguita, a quel punto l'espressione viene valutata e fornisce un valore.The DynamicResource Markup Extension instead processes a key by creating an expression, and that expression remains unevaluated until the app runs, at which time the expression is evaluated and provides a value.

Quando si fa riferimento a una risorsa, la decisione di usare un riferimento di risorsa statica o un riferimento di risorsa dinamica può essere influenzata dalle considerazioni seguenti:When you reference a resource, the following considerations can influence whether you use a static resource reference or a dynamic resource reference:

  • Quando si determina la progettazione complessiva della modalità di creazione delle risorse per l'app (per pagina, nell'app, in XAML separato o in un assembly di sole risorse), tenere presente quanto segue:When determining the overall design of how you create the resources for your app (per page, in the app, in loose XAML, or in a resource-only assembly), consider the following:

  • Funzionalità dell'app.The app's functionality. Sono in corso l'aggiornamento delle risorse in tempo reale nei requisiti dell'app?Are updating resources in real-time part of your app requirements?

  • Il comportamento di ricerca specifico del tipo di riferimento di risorsa.The respective lookup behavior of that resource reference type.

  • La proprietà o il tipo di risorsa specifico e il comportamento nativo di tale tipo.The particular property or resource type, and the native behavior of those types.

Risorse staticheStatic resources

I riferimenti di risorse statiche sono ideali nelle circostanze seguenti:Static resource references work best for the following circumstances:

  • La progettazione dell'app concentra la maggior parte delle risorse nei dizionari risorse a livello di pagina o di applicazione.Your app design concentrates most of its resources into page or application-level resource dictionaries. I riferimenti alle risorse statiche non vengono rivalutati in base ai comportamenti di runtime, ad esempio il ricaricamento di una pagina.Static resource references aren't reevaluated based on runtime behaviors, such as reloading a page. Pertanto, è possibile che si verifichi un vantaggio in merito alle prestazioni per evitare un numero elevato di riferimenti a risorse dinamiche quando questi non sono necessari in base alla progettazione delle risorse e delle app.So there can be some performance benefit to avoiding large numbers of dynamic resource references when they aren't necessary based on your resource and app design.

  • Si sta impostando il valore di una proprietà che non si trova in un oggetto DependencyObject o Freezable .You're setting the value of a property that isn't on a DependencyObject or a Freezable.

  • Si sta creando un dizionario risorse che verrà compilato in una DLL e incluso in un pacchetto come parte dell'app o condiviso tra le app.You're creating a resource dictionary that will be compiled into a DLL and packaged as part of the app or shared between apps.

  • Si sta creando un tema per un controllo personalizzato e si definiscono le risorse usate nei temi.You're creating a theme for a custom control and are defining resources that are used within the themes. In questo caso, non si desidera in genere il comportamento di ricerca dei riferimenti alle risorse dinamiche. si desidera invece il comportamento del riferimento a una risorsa statica in modo che la ricerca sia prevedibile e autonoma al tema.For this case, you typically do not want the dynamic resource reference lookup behavior; you instead want the static resource reference behavior so that the lookup is predictable and self-contained to the theme. Con un riferimento a una risorsa dinamica, anche un riferimento all'interno di un tema viene lasciato non valutato fino alla fase di esecuzione.With a dynamic resource reference, even a reference within a theme is left unevaluated until run-time. e c'è la possibilità che, quando il tema viene applicato, alcuni elementi locali ridefiniranno una chiave a cui il tema sta provando a fare riferimento e l'elemento locale rientrerà prima del tema stesso nella ricerca.and there is a chance that when the theme is applied, some local element will redefine a key that your theme is trying to reference, and the local element will fall prior to the theme itself in the lookup. In tal caso, il tema non si comporta come previsto.If that happens, your theme will not behave as expected.

  • Si stanno usando risorse per impostare un numero elevato di proprietà di dipendenza.You're using resources to set large numbers of dependency properties. Le proprietà di dipendenza hanno una memorizzazione nella cache dei valori effettiva abilitata dal sistema di proprietà, pertanto se si fornisce un valore per una proprietà di dipendenza che può essere valutata in fase di caricamento, la proprietà di dipendenza non deve verificare la presenza di un'espressione rivalutata e può restituire l'ultimo valore effettivo.Dependency properties have effective value caching as enabled by the property system, so if you provide a value for a dependency property that can be evaluated at load time, the dependency property doesn't have to check for a reevaluated expression and can return the last effective value. Questa tecnica può garantire un miglioramento delle prestazioni.This technique can be a performance benefit.

  • Si desidera modificare la risorsa sottostante per tutti i consumer oppure si desidera mantenere istanze scrivibili separate per ogni consumer utilizzando l' attributo x:Shared.You want to change the underlying resource for all consumers, or you want to maintain separate writable instances for each consumer by using the x:Shared Attribute.

Comportamento di ricerca delle risorse staticheStatic resource lookup behavior

Di seguito viene descritto il processo di ricerca che si verifica automaticamente quando una proprietà o un elemento fa riferimento a una risorsa statica:The following describes the lookup process that automatically happens when a static resource is referenced by a property or element:

  1. Il processo di ricerca controlla la presenza della chiave richiesta all'interno del dizionario risorse definito dall'elemento che imposta la proprietà.The lookup process checks for the requested key within the resource dictionary defined by the element that sets the property.

  2. Il processo di ricerca attraversa quindi l'albero logico verso l'alto all'elemento padre e al relativo dizionario risorse.The lookup process then traverses the logical tree upward to the parent element and its resource dictionary. Questo processo continua fino a quando non viene raggiunto l'elemento radice.This process continues until the root element is reached.

  3. Le risorse dell'app vengono controllate.App resources are checked. Le risorse dell'app sono le risorse all'interno del dizionario risorse definito dall' Application oggetto per l'app WPF.App resources are those resources within the resource dictionary that is defined by the Application object for your WPF app.

I riferimenti di risorse statiche all'interno di un dizionario risorse devono fare riferimento a una risorsa già definita lessicalmente prima del riferimento.Static resource references from within a resource dictionary must reference a resource that has already been defined lexically before the resource reference. I riferimenti di risorse statiche non sono in grado di risolvere riferimenti in avanti.Forward references cannot be resolved by a static resource reference. Per questo motivo, progettare la struttura del dizionario risorse in modo che le risorse vengano definite in corrispondenza o in prossimità dell'inizio di ogni rispettivo dizionario risorse.For this reason, design your resource dictionary structure such that resources are defined at or near the beginning of each respective resource dictionary.

La ricerca di risorse statiche può estendersi nei temi o nelle risorse di sistema, ma questa ricerca è supportata solo perché il caricatore XAML rinvia la richiesta.Static resource lookup can extend into themes or into system resources, but this lookup is supported only because the XAML loader defers the request. Il rinvio è necessario in modo che il tema del runtime al momento del caricamento della pagina venga applicato correttamente all'app.The deferral is necessary so that the runtime theme at the time the page loads applies properly to the app. Tuttavia, i riferimenti a risorse statiche a chiavi note a esistere solo nei temi o come risorse di sistema non sono consigliate, perché tali riferimenti non vengono rivalutati se il tema viene modificato dall'utente in tempo reale.However, static resource references to keys that are known to only exist in themes or as system resources aren't recommended, because such references aren't reevaluated if the theme is changed by the user in real time. Un riferimento di risorsa dinamica è più affidabile se si richiedono risorse di tema o di sistema.A dynamic resource reference is more reliable when you request theme or system resources. Fa eccezione il caso in cui un elemento tema stesso richieda un'altra risorsa.The exception is when a theme element itself requests another resource. Per i motivi descritti in precedenza, questi riferimenti devono essere riferimenti di risorse statiche.These references should be static resource references, for the reasons mentioned earlier.

Il comportamento dell'eccezione se non viene trovato un riferimento a una risorsa statica varia.The exception behavior if a static resource reference isn't found varies. Se la risorsa è stata rinviata, l'eccezione si verifica in runtime.If the resource was deferred, then the exception occurs at runtime. Se la risorsa non è stata rinviata, l'eccezione si verifica al momento del caricamento.If the resource was not deferred, the exception occurs at load time.

Risorse dinamicheDynamic resources

Le risorse dinamiche funzionano meglio nei casi seguenti:Dynamic resources work best when:

  • Il valore della risorsa, incluse le risorse di sistema o le risorse che sono altrimenti impostabili dall'utente, dipende dalle condizioni che non sono note fino al runtime.The value of the resource, including system resources, or resources that are otherwise user settable, depends on conditions that aren't known until runtime. È ad esempio possibile creare valori Setter che fanno riferimento alle proprietà di sistema esposte da SystemColors , SystemFonts o SystemParameters .For example, you can create setter values that refer to system properties as exposed by SystemColors, SystemFonts, or SystemParameters. Questi valori sono realmente dinamici perché in ultima analisi derivano dall'ambiente di runtime dell'utente e dal sistema operativo.These values are truly dynamic because they ultimately come from the runtime environment of the user and operating system. È anche possibile che eventuali temi a livello di applicazione siano soggetti a modifica e che l'accesso alle risorse a livello di pagina debba anche acquisire la modifica.You might also have application-level themes that can change, where page-level resource access must also capture the change.

  • Si stanno creando o facendo riferimento a stili di tema per un controllo personalizzato.You're creating or referencing theme styles for a custom control.

  • Si intende modificare il contenuto di un ResourceDictionary durante la durata di un'app.You intend to adjust the contents of a ResourceDictionary during an app lifetime.

  • La struttura delle risorse è complessa e con interdipendenze e potrebbe richiedere riferimenti in avanti.You have a complicated resource structure that has interdependencies, where a forward reference may be required. I riferimenti alle risorse statiche non supportano i riferimenti in diretta, ma i riferimenti alle risorse dinamiche le supportano perché la risorsa non deve essere valutata fino al runtime e i riferimenti in diretta non sono pertanto un concetto pertinente.Static resource references do not support forward references, but dynamic resource references do support them because the resource doesn't need to be evaluated until runtime, and forward references are therefore not a relevant concept.

  • Si fa riferimento a una risorsa di grandi dimensioni dal punto di vista di una compilazione o di una working set e la risorsa potrebbe non essere utilizzata immediatamente quando viene caricata la pagina.You're referencing a resource that is large from the perspective of a compile or working set, and the resource might not be used immediately when the page loads. I riferimenti a risorse statiche vengono sempre caricati da XAML quando viene caricata la pagina.Static resource references always load from XAML when the page loads. Tuttavia, un riferimento a una risorsa dinamica non viene caricato fino a quando non viene utilizzato.However, a dynamic resource reference doesn't load until it's used.

  • Si sta creando uno stile in cui i valori Setter possono provenire da altri valori influenzati da temi o altre impostazioni utente.You're creating a style where setter values might come from other values that are influenced by themes or other user settings.

  • Si applicano risorse a elementi che possono essere associati a un nuovo elemento padre nell'albero logico durante la durata dell'app.You're applying resources to elements that might be reparented in the logical tree during app lifetime. La modifica dell'elemento padre cambia potenzialmente anche l'ambito di ricerca. Se quindi si vuole che la risorsa per un elemento associato a un nuovo elemento padre sia rivalutata in base al nuovo ambito, usare sempre un riferimento di risorsa dinamica.Changing the parent also potentially changes the resource lookup scope, so if you want the resource for a reparented element to be reevaluated based on the new scope, always use a dynamic resource reference.

Comportamento di ricerca delle risorse dinamicheDynamic resource lookup behavior

Il comportamento di ricerca delle risorse per un riferimento a una risorsa dinamica è parallelo al comportamento di ricerca nel codice se si chiama FindResource o SetResourceReference :Resource lookup behavior for a dynamic resource reference parallels the lookup behavior in your code if you call FindResource or SetResourceReference:

  1. La ricerca controlla la chiave richiesta all'interno del dizionario risorse definito dall'elemento che imposta la proprietà:The lookup checks for the requested key within the resource dictionary defined by the element that sets the property:

  2. La ricerca attraversa l'albero logico verso l'alto all'elemento padre e al relativo dizionario risorse.The lookup traverses the logical tree upward to the parent element and its resource dictionary. Questo processo continua fino a quando non viene raggiunto l'elemento radice.This process continues until the root element is reached.

  3. Le risorse dell'app vengono controllate.App resources are checked. Le risorse dell'app sono le risorse all'interno del dizionario risorse definite dall' Application oggetto per l'app WPF.App resources are those resources within the resource dictionary that are defined by the Application object for your WPF app.

  4. Il tema del dizionario risorse del tema è selezionato per il tema attualmente attivo.The theme resource dictionary is checked for the currently active theme. Se il tema viene modificato in runtime, il valore viene rivalutato.If the theme changes at runtime, the value is reevaluated.

  5. Vengono controllate le risorse di sistema.System resources are checked.

Il comportamento di eventuali eccezioni varia:Exception behavior (if any) varies:

  • Se una risorsa è stata richiesta da una FindResource chiamata e non è stata trovata, viene generata un'eccezione.If a resource was requested by a FindResource call and was not found, an exception is thrown.

  • Se una risorsa è stata richiesta da una TryFindResource chiamata e non è stata trovata, non viene generata alcuna eccezione e il valore restituito è null .If a resource was requested by a TryFindResource call and was not found, no exception is thrown, and the returned value is null. Se la proprietà impostata non accetta null , è comunque possibile che venga generata un'eccezione più profonda, a seconda della singola proprietà da impostare.If the property being set doesn't accept null, then it's still possible that a deeper exception will be thrown, depending on the individual property being set.

  • Se una risorsa è stata richiesta da un riferimento a una risorsa dinamica in XAML e non è stata trovata, il comportamento dipende dal sistema di proprietà generale.If a resource was requested by a dynamic resource reference in XAML and was not found, then the behavior depends on the general property system. Il comportamento generale è come se non fosse stata eseguita un'operazione di impostazione delle proprietà a livello di risorsa.The general behavior is as if no property setting operation occurred at the level where the resource exists. Se, ad esempio, si tenta di impostare lo sfondo di un singolo elemento Button usando una risorsa che non è stato possibile valutare, non viene restituito alcun valore, ma il valore effettivo può comunque provenire da altri partecipanti nel sistema di proprietà e nella precedenza dei valori.For instance, if you attempt to set the background on an individual button element using a resource that could not be evaluated, then no value set results, but the effective value can still come from other participants in the property system and value precedence. Il valore dello sfondo, ad esempio, può provenire da uno stile di pulsante definito localmente o dallo stile del tema.For instance, the background value might still come from a locally defined button style or from the theme style. Per le proprietà che non sono definite dagli stili del tema, il valore effettivo dopo una valutazione di risorse non riuscite potrebbe derivare dal valore predefinito nei metadati della proprietà.For properties that aren't defined by theme styles, the effective value after a failed resource evaluation might come from the default value in the property metadata.

RestrizioniRestrictions

I riferimenti di risorse dinamiche presentano alcune restrizioni rilevanti.Dynamic resource references have some notable restrictions. È necessario che sia soddisfatta almeno una delle condizioni seguenti:At least one of the following conditions must be true:

Poiché la proprietà impostata deve essere una DependencyProperty proprietà o Freezable , la maggior parte delle modifiche alle proprietà può propagarsi all'interfaccia utente perché una modifica di proprietà (il valore della risorsa dinamica modificata) viene riconosciuta dal sistema di proprietà.Because the property being set must be a DependencyProperty or Freezable property, most property changes can propagate to the UI because a property change (the changed dynamic resource value) is acknowledged by the property system. La maggior parte dei controlli include la logica che forza un altro layout di un controllo se una DependencyProperty modifica e tale proprietà potrebbe influire sul layout.Most controls include logic that will force another layout of a control if a DependencyProperty changes and that property might affect layout. Tuttavia, non tutte le proprietà che dispongono di un' estensione di markup DynamicResource come valore sono garantite per fornire aggiornamenti in tempo reale nell'interfaccia utente.However, not all properties that have a DynamicResource Markup Extension as their value are guaranteed to provide real time updates in the UI. Tale funzionalità può comunque variare a seconda della proprietà, nonché a seconda del tipo proprietario della proprietà o anche della struttura logica dell'app.That functionality still might vary depending on the property, as well as depending on the type that owns the property, or even the logical structure of your app.

Stili, DataTemplate e chiavi impliciteStyles, DataTemplates, and implicit keys

Sebbene tutti gli elementi in un oggetto ResourceDictionary debbano avere una chiave, questo non significa che tutte le risorse devono avere un oggetto esplicito x:Key .Although all items in a ResourceDictionary must have a key, that doesn't mean that all resources must have an explicit x:Key. Diversi tipi di oggetto supportano una chiave implicita quando sono definiti come risorsa in cui il valore della chiave è associato al valore di un'altra proprietà.Several object types support an implicit key when defined as a resource, where the key value is tied to the value of another property. Questo tipo di chiave è noto come chiave implicita, mentre un x:Key attributo è una chiave esplicita.This type of key is known as an implicit key, whereas an x:Key attribute is an explicit key. È possibile sovrascrivere qualsiasi chiave implicita specificando una chiave esplicita.You can overwrite any implicit key by specifying an explicit key.

Uno scenario importante per le risorse è quando si definisce un Style .One important scenario for resources is when you define a Style. In realtà, un Style è quasi sempre definito come una voce in un dizionario risorse, perché gli stili sono intrinsecamente progettati per il riutilizzo.In fact, a Style is almost always defined as an entry in a resource dictionary, because styles are inherently intended for reuse. Per altre informazioni sugli stili, vedere applicazione di stili e modelli.For more information about styles, see Styling and Templating.

Una chiave implicita consente sia di creare stili per controlli che di fare riferimento ad essi.Styles for controls can be both created with and referenced with an implicit key. Gli stili di tema che definiscono l'aspetto predefinito di un controllo si basano sulla chiave implicita.The theme styles that define the default appearance of a control rely on this implicit key. Dal punto di vista della richiesta, la chiave implicita è la Type del controllo stesso.From the standpoint of requesting it, the implicit key is the Type of the control itself. Dal punto di vista della definizione delle risorse, la chiave implicita è il TargetType dello stile.From the standpoint of defining the resources, the implicit key is the TargetType of the style. Di conseguenza, se si creano temi per i controlli personalizzati o si creano stili che interagiscono con gli stili del tema esistenti, non è necessario specificare una direttiva x:Key Style .Therefore, if you're creating themes for custom controls or creating styles that interact with existing theme styles, you do not need to specify an x:Key Directive for that Style. E se si vogliono usare stili con tema, non è necessario specificare alcuno stile.And if you want to use the themed styles, you do not need to specify any style at all. Ad esempio, la definizione di stile seguente funziona anche se la Style risorsa non presenta una chiave:For instance, the following style definition works, even though the Style resource doesn't appear to have a key:

<Style TargetType="Button">
  <Setter Property="Background">
    <Setter.Value>
      <LinearGradientBrush>
        <GradientStop Offset="0.0" Color="AliceBlue"/>
        <GradientStop Offset="1.0" Color="Salmon"/>           
      </LinearGradientBrush>
    </Setter.Value>
  </Setter>  
  <Setter Property="FontSize" Value="18"/>
</Style>

Lo stile ha effettivamente una chiave, ovvero la chiave implicita typeof(System.Windows.Controls.Button) .That style really does have a key: the implicit key typeof(System.Windows.Controls.Button). Nel markup è possibile specificare TargetType direttamente come nome del tipo (oppure è possibile usare facoltativamente {x:Type...}In markup, you can specify a TargetType directly as the type name (or you can optionally use {x:Type...} per restituire un oggetto Type .to return a Type.

Attraverso i meccanismi di stile del tema predefiniti usati da WPF, lo stile viene applicato come stile di runtime di un oggetto Button nella pagina, anche se Button non tenta di specificare la Style proprietà o un riferimento a una risorsa specifica nello stile.Through the default theme style mechanisms used by WPF, that style is applied as the runtime style of a Button on the page, even though the Button itself doesn't attempt to specify its Style property or a specific resource reference to the style. Lo stile definito nella pagina viene trovato in precedenza nella sequenza di ricerca rispetto allo stile del dizionario dei temi, usando la stessa chiave dello stile del dizionario del tema.Your style defined in the page is found earlier in the lookup sequence than the theme dictionary style, using the same key that the theme dictionary style has. È possibile specificare semplicemente <Button>Hello</Button> un punto qualsiasi della pagina e lo stile definito con si TargetType Button applica a tale pulsante.You could just specify <Button>Hello</Button> anywhere in the page, and the style you defined with TargetType of Button would apply to that button. Se lo si desidera, è comunque possibile impostare in modo esplicito come chiave lo stile con lo stesso valore di tipo TargetType di per chiarezza nel markup, ma questo è facoltativo.If you want, you can still explicitly key the style with the same type value as TargetType for clarity in your markup, but that is optional.

Le chiavi implicite per gli stili non si applicano a un controllo se OverridesDefaultStyle è true .Implicit keys for styles do not apply on a control if OverridesDefaultStyle is true. Si noti anche che OverridesDefaultStyle può essere impostato come parte del comportamento nativo per la classe del controllo, anziché in modo esplicito in un'istanza del controllo. Inoltre, per supportare le chiavi implicite per gli scenari di classi derivate, il controllo deve eseguire l'override di DefaultStyleKey (tutti i controlli esistenti forniti come parte di WPF includono questo override).(Also note that OverridesDefaultStyle might be set as part of native behavior for the control class, rather than explicitly on an instance of the control.) Also, in order to support implicit keys for derived class scenarios, the control must override DefaultStyleKey (all existing controls provided as part of WPF include this override). Per ulteriori informazioni su stili, temi e progettazione di controlli, vedere linee guida per la progettazione di controlli Stylable.For more information about styles, themes, and control design, see Guidelines for Designing Stylable Controls.

DataTemplate dispone inoltre di una chiave implicita.DataTemplate also has an implicit key. La chiave implicita per un oggetto DataTemplate è il DataType valore della proprietà.The implicit key for a DataTemplate is the DataType property value. DataType può anche essere specificato come nome del tipo anziché usare in modo esplicito {x:Type...}.DataType can also be specified as the name of the type rather than explicitly using {x:Type...}. Per informazioni dettagliate, vedere Cenni preliminari sui modelli di dati.For details, see Data Templating Overview.

Vedere ancheSee also