Přehled prostředků XAML (WPF .NET)Overview of XAML resources (WPF .NET)

Prostředek je objekt, který lze znovu použít na různých místech aplikace.A resource is an object that can be reused in different places in your app. Mezi příklady prostředků patří štětce a styly.Examples of resources include brushes and styles. Tento přehled popisuje, jak používat prostředky v jazyk Extensible Application Markup Language (XAML) (XAML).This overview describes how to use resources in Extensible Application Markup Language (XAML). Můžete také vytvořit prostředky a přistupovat k nim pomocí kódu.You can also create and access resources by using code.

Poznámka

Prostředky XAML popsané v tomto článku se liší od prostředků aplikace , které jsou obecně soubory přidané do aplikace, jako je například obsah, data nebo vložené soubory.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.

Důležité

V dokumentaci k desktopové příručce pro .NET 5 (a .NET Core) se provádí konstrukce.The Desktop Guide documentation for .NET 5 (and .NET Core) is under construction.

Používání prostředků v jazyce XAMLUsing resources in XAML

Následující příklad definuje SolidColorBrush jako prostředek v kořenovém elementu stránky.The following example defines a SolidColorBrush as a resource on the root element of a page. Příklad pak odkazuje na prostředek a použije ho k nastavení vlastností několika podřízených elementů, včetně Ellipse , a TextBlock a 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>


Každý element na úrovni architektury ( FrameworkElement nebo FrameworkContentElement ) má Resources vlastnost, která je ResourceDictionary typu, který obsahuje definované prostředky.Every framework-level element (FrameworkElement or FrameworkContentElement) has a Resources property, which is a ResourceDictionary type that contains defined resources. Můžete definovat prostředky pro libovolný element, jako je například Button .You can define resources on any element, such as a Button. Prostředky jsou však nejčastěji definovány na kořenovém prvku, který je Page v příkladu.However, resources are most often defined on the root element, which is Page in the example.

Každý prostředek ve slovníku prostředků musí mít jedinečný klíč.Each resource in a resource dictionary must have a unique key. Při definování prostředků v kódu přiřadíte jedinečný klíč prostřednictvím direktivy x:Key –.When you define resources in markup, you assign the unique key through the x:Key Directive. Klíč je obvykle řetězec. můžete ji však také nastavit na jiné typy objektů pomocí příslušných rozšíření značek.Typically, the key is a string; however, you can also set it to other object types by using the appropriate markup extensions. Neřetězcové klíče pro prostředky jsou používány některými oblastmi funkcí v technologii WPF, zejména pro styly, prostředky komponent a pro datové styly.Non-string keys for resources are used by certain feature areas in WPF, notably for styles, component resources, and data styling.

Můžete použít definovaný prostředek se syntaxí rozšíření značek prostředku, která určuje název prostředku.You can use a defined resource with the resource markup extension syntax that specifies the key name of the resource. Například použijte prostředek jako hodnotu vlastnosti v jiném elementu.For example, use the resource as the value of a property on another element.

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

V předchozím příkladu, když zavaděč XAML zpracovává hodnotu {StaticResource MyBrush} pro Background vlastnost na Button , logika vyhledávání prostředků nejprve zkontroluje slovník prostředků pro daný Button element.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. Pokud nemá Button definici klíče prostředků MyBrush (v tomto příkladu to není; jeho kolekce prostředků je prázdná), vyhledávání provede další kontrolu nadřazeného elementu Button , který je 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. Definujete-li prostředek na Page kořenovém prvku, budou mít k němu přístup všechny prvky v logickém stromu Page .If you define a resource on the Page root element, all the elements in the logical tree of the Page can access it. A můžete použít stejný prostředek pro nastavení hodnoty libovolné vlastnosti, která bude přijímat stejný typ, jaký prostředek představuje.And you can reuse the same resource for setting the value of any property that accepts the same type that the resource represents. V předchozím příkladu stejný MyBrush prostředek nastaví dvě různé vlastnosti: Background Button a, a a Fill Rectangle .In the previous example, the same MyBrush resource sets two different properties: the Background of a Button, and the Fill of a Rectangle.

Statické a dynamické prostředkyStatic and dynamic resources

Prostředek se může odkazovat buď na statický, nebo na dynamický.A resource can be referenced as either static or dynamic. Odkazy se vytvářejí buď pomocí rozšíření značek StaticResource , nebo pomocí rozšíření značek DynamicResource.References are created by using either the StaticResource Markup Extension or the DynamicResource Markup Extension. Rozšíření značek je funkce jazyka XAML, která umožňuje zadat odkaz na objekt pomocí rozšíření značek, který zpracovává řetězec atributu a vrátí objekt do zavaděče 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. Další informace o chování rozšíření značek naleznete v tématu rozšíření značek a WPF XAML.For more information about markup extension behavior, see Markup Extensions and WPF XAML.

Použijete-li rozšíření značek, obvykle zadáte jeden nebo více parametrů ve formě řetězce, které jsou zpracovány konkrétní příponou označení.When you use a markup extension, you typically provide one or more parameters in string form that are processed by that particular markup extension. Přípona značek StaticResource zpracuje klíč tím, že vyhledá hodnotu pro tento klíč ve všech dostupných slovníkech prostředků.The StaticResource Markup Extension processes a key by looking up the value for that key in all available resource dictionaries. Zpracování probíhá během načítání, což je, když proces načítání potřebuje přiřadit hodnotu vlastnosti.Processing happens during load, which is when the loading process needs to assign the property value. Rozšíření značek DynamicResource místo toho zpracovává klíč tím, že vytvoří výraz a tento výraz zůstane nevyhodnocený, dokud se aplikace nespustí, přičemž v takovém případě je výraz vyhodnocen a poskytuje hodnotu.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.

Při odkazování na prostředek mohou následující okolnosti ovlivnit, zda používáte statický odkaz na prostředek nebo dynamický odkaz na prostředek:When you reference a resource, the following considerations can influence whether you use a static resource reference or a dynamic resource reference:

  • Při určování celkového návrhu způsobu vytváření prostředků pro vaši aplikaci (na stránce, v aplikaci, ve volném XAML nebo v sestavení pouze pro prostředky) Vezměte v úvahu následující skutečnosti: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:

  • Funkce aplikaceThe app's functionality. Aktualizujete prostředky v rámci požadavků vaší aplikace v reálném čase?Are updating resources in real-time part of your app requirements?

  • Příslušné chování vyhledávání tohoto typu odkazu na prostředek.The respective lookup behavior of that resource reference type.

  • Konkrétní vlastnost nebo typ prostředku a nativní chování těchto typů.The particular property or resource type, and the native behavior of those types.

Statické prostředkyStatic resources

Odkazy statických prostředků fungují nejlépe v následujících případech:Static resource references work best for the following circumstances:

  • Návrh vaší aplikace soustředí většinu svých prostředků na stránky nebo slovníky prostředků na úrovni aplikace.Your app design concentrates most of its resources into page or application-level resource dictionaries. Statické odkazy na prostředky nejsou znovu vyhodnoceny na základě chování modulu runtime, jako je například opětovné načtení stránky.Static resource references aren't reevaluated based on runtime behaviors, such as reloading a page. Takže může vycházet z nějakého zvýšení výkonu a vyhnout se tak velkému počtu dynamických odkazů na prostředky, pokud to není nutné na základě návrhu prostředků a aplikací.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.

  • Nastavujete hodnotu vlastnosti, která není na DependencyObject nebo Freezable .You're setting the value of a property that isn't on a DependencyObject or a Freezable.

  • Vytváříte slovník prostředků, který se zkompiluje do knihovny DLL a zabalí se jako součást aplikace nebo se sdílí mezi aplikacemi.You're creating a resource dictionary that will be compiled into a DLL and packaged as part of the app or shared between apps.

  • Vytváříte motiv pro vlastní ovládací prvek a definujete prostředky, které se používají v rámci motivů.You're creating a theme for a custom control and are defining resources that are used within the themes. V tomto případě obvykle nechcete, aby bylo vyhledávání v odkazu dynamického prostředku. místo toho chcete, aby bylo chování odkazu statického prostředku tak, aby bylo vyhledávání předvídatelné a samoně součástí motivu.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. S odkazem na dynamický prostředek, dokonce i odkaz v rámci motivu je ponechán nehodnocený, dokud nespustíte rutinu run-time.With a dynamic resource reference, even a reference within a theme is left unevaluated until run-time. a existuje možnost, že když je motiv použit, některé lokální prvky předefinují klíč, na který se váš motiv pokouší odkazovat, a místní prvek bude před samotným motivem ve vyhledávání.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. Pokud k tomu dojde, váš motiv se nebude chovat podle očekávání.If that happens, your theme will not behave as expected.

  • Prostředky se používají k nastavení velkého počtu vlastností závislosti.You're using resources to set large numbers of dependency properties. Vlastnosti závislosti mají efektivní ukládání hodnot do mezipaměti, které jsou povolené systémem vlastností, takže pokud zadáte hodnotu pro vlastnost závislosti, kterou je možné vyhodnotit během načítání, vlastnost Dependency nemusí kontrolovat znovu vyhodnocený výraz a může vrátit poslední efektivní hodnotu.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. Tato technika může být výhodou výkonu.This technique can be a performance benefit.

  • Chcete změnit základní prostředek pro všechny uživatele nebo chcete zachovat samostatné zapisovatelné instance pro každého příjemce pomocí atributu 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.

Chování vyhledávání statických prostředkůStatic resource lookup behavior

Následující článek popisuje proces vyhledávání, který se automaticky stane, když na statický prostředek odkazuje vlastnost nebo element:The following describes the lookup process that automatically happens when a static resource is referenced by a property or element:

  1. Proces vyhledávání kontroluje požadovaný klíč v rámci slovníku prostředků definovaného prvkem, který nastavuje vlastnost.The lookup process checks for the requested key within the resource dictionary defined by the element that sets the property.

  2. Proces vyhledávání pak projde logický strom směrem nahoru k nadřazenému elementu a jeho slovníku prostředků.The lookup process then traverses the logical tree upward to the parent element and its resource dictionary. Tento proces pokračuje, dokud není dosaženo kořenového prvku.This process continues until the root element is reached.

  3. Prostředky aplikace jsou zkontrolovány.App resources are checked. Prostředky aplikací jsou tyto prostředky v rámci slovníku prostředků, který je definovaný Application objektem pro vaši aplikaci WPF.App resources are those resources within the resource dictionary that is defined by the Application object for your WPF app.

Statické odkazy na prostředky v rámci slovníku prostředků musí odkazovat na prostředek, který již byl definován lexikální před odkazem na prostředek.Static resource references from within a resource dictionary must reference a resource that has already been defined lexically before the resource reference. Odkazy na směrování nelze vyřešit pomocí odkazu na statický prostředek.Forward references cannot be resolved by a static resource reference. Z tohoto důvodu je třeba navrhnout strukturu slovníku prostředků tak, aby prostředky byly definovány na začátku každého příslušného slovníku prostředků nebo téměř na nich.For this reason, design your resource dictionary structure such that resources are defined at or near the beginning of each respective resource dictionary.

Statické vyhledávání prostředků může být rozšířeno na motivy nebo do systémových prostředků, ale toto vyhledávání je podporováno pouze proto, že zavaděč XAML odloží požadavek.Static resource lookup can extend into themes or into system resources, but this lookup is supported only because the XAML loader defers the request. Odložení je nezbytné, aby byl motiv modulu runtime v okamžiku, kdy se stránka správně načte, v aplikaci správně načítat.The deferral is necessary so that the runtime theme at the time the page loads applies properly to the app. Nicméně statické odkazy na klíče, které jsou známy pouze v motivech nebo jako systémové prostředky, nejsou doporučovány, protože tyto odkazy nejsou znovu vyhodnoceny, pokud je motiv změněn uživatelem v reálném čase.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. Odkaz na dynamický prostředek je spolehlivější, když požádáte o motiv nebo systémové prostředky.A dynamic resource reference is more reliable when you request theme or system resources. Výjimkou je, když prvek motivu sám požaduje jiný prostředek.The exception is when a theme element itself requests another resource. Tyto odkazy by měly být statickými odkazy na prostředky z výše zmíněných důvodů.These references should be static resource references, for the reasons mentioned earlier.

Chování výjimky, pokud není nalezen statický odkaz na prostředek, se liší.The exception behavior if a static resource reference isn't found varies. Pokud byl prostředek odložen, dojde k výjimce za běhu.If the resource was deferred, then the exception occurs at runtime. Pokud prostředek nebyl odložen, dojde k výjimce v době načítání.If the resource was not deferred, the exception occurs at load time.

Dynamické prostředkyDynamic resources

Dynamické prostředky fungují nejlépe v těchto případech:Dynamic resources work best when:

  • Hodnota prostředku, včetně systémových prostředků nebo prostředků, které jinak nastaví uživatel, závisí na podmínkách, které nejsou známy až do doby běhu.The value of the resource, including system resources, or resources that are otherwise user settable, depends on conditions that aren't known until runtime. Můžete například vytvořit hodnoty Setter, které odkazují na vlastnosti systému, které jsou zpřístupněny pomocí SystemColors , SystemFonts nebo SystemParameters .For example, you can create setter values that refer to system properties as exposed by SystemColors, SystemFonts, or SystemParameters. Tyto hodnoty jsou skutečně dynamické, protože nakonec pocházejí z běhového prostředí uživatele a operačního systému.These values are truly dynamic because they ultimately come from the runtime environment of the user and operating system. Můžete mít také motivy na úrovni aplikace, které mohou být změněny, kde přístup k prostředkům na úrovni stránky musí také zachytit změnu.You might also have application-level themes that can change, where page-level resource access must also capture the change.

  • Vytváříte nebo odkazujete na styly motivů pro vlastní ovládací prvek.You're creating or referencing theme styles for a custom control.

  • Máte v úmyslu upravit obsah ResourceDictionary během životnosti aplikace.You intend to adjust the contents of a ResourceDictionary during an app lifetime.

  • Máte složitou strukturu prostředků, která má vzájemné závislosti, kde se může vyžadovat dopředný odkaz.You have a complicated resource structure that has interdependencies, where a forward reference may be required. Statické odkazy na prostředky nepodporují dopředné odkazy, ale dynamické odkazy na prostředky je podporují, protože prostředek není nutné vyhodnotit do doby, než je modul runtime, a předávací odkazy nejsou proto relevantní koncept.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.

  • Odkazujete na prostředek, který je velký z perspektivy kompilace nebo pracovní sady, a prostředek se nemusí použít ihned při načtení stránky.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. Statické odkazy na prostředky se při načtení stránky vždy načítají z kódu XAML.Static resource references always load from XAML when the page loads. Dynamický odkaz na prostředek se ale nenačte, dokud se nepoužije.However, a dynamic resource reference doesn't load until it's used.

  • Vytváříte styl, ve kterém mohou být hodnoty setter z jiných hodnot, které jsou ovlivněny motivy nebo jinými uživatelskými nastaveními.You're creating a style where setter values might come from other values that are influenced by themes or other user settings.

  • Prostředky se aplikují na prvky, které můžou být v logickém stromu během životnosti aplikace znovu nadřazené.You're applying resources to elements that might be reparented in the logical tree during app lifetime. Změna nadřazené položky také potenciálně změní rozsah vyhledávání prostředků, takže pokud chcete, aby byl prostředek pro předaný element znovu vyhodnocen v závislosti na novém oboru, vždy použijte dynamický odkaz na prostředek.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.

Chování při hledání dynamického prostředkuDynamic resource lookup behavior

Chování vyhledávání prostředků pro odkaz na dynamický prostředek paralelně vytvoří chování vyhledávání v kódu, pokud voláte FindResource nebo SetResourceReference :Resource lookup behavior for a dynamic resource reference parallels the lookup behavior in your code if you call FindResource or SetResourceReference:

  1. Vyhledávání vyhledá požadovaný klíč v rámci slovníku prostředků definovaného prvkem, který nastavuje vlastnost:The lookup checks for the requested key within the resource dictionary defined by the element that sets the property:

  2. Vyhledávání projde logický strom směrem nahoru k nadřazenému prvku a jeho slovníku prostředků.The lookup traverses the logical tree upward to the parent element and its resource dictionary. Tento proces pokračuje, dokud není dosaženo kořenového prvku.This process continues until the root element is reached.

  3. Prostředky aplikace jsou zkontrolovány.App resources are checked. Prostředky aplikací jsou tyto prostředky v rámci slovníku prostředků, které jsou definovány Application objektem pro vaši aplikaci WPF.App resources are those resources within the resource dictionary that are defined by the Application object for your WPF app.

  4. Slovník prostředků motivu je kontrolován pro aktuálně aktivní motiv.The theme resource dictionary is checked for the currently active theme. Pokud se motiv změní za běhu, hodnota se znovu vyhodnotí.If the theme changes at runtime, the value is reevaluated.

  5. Jsou zaškrtnuté systémové prostředky.System resources are checked.

Chování výjimky (pokud existuje) se liší:Exception behavior (if any) varies:

  • Pokud byl prostředek vyžádán FindResource voláním a nebyl nalezen, je vyvolána výjimka.If a resource was requested by a FindResource call and was not found, an exception is thrown.

  • Pokud byl prostředek vyžádán TryFindResource voláním a nebyl nalezen, není vyvolána žádná výjimka a vrácená hodnota je null .If a resource was requested by a TryFindResource call and was not found, no exception is thrown, and the returned value is null. Pokud vlastnost nastavená nepřijímá null , je stále možné, že bude vyvolána hlubší výjimka v závislosti na nastavené individuální vlastnosti.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.

  • Pokud byl prostředek vyžádán odkazem dynamického prostředku v jazyce XAML a nebyl nalezen, bude chování záviset na obecném systému vlastností.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. Obecné chování je, jako kdyby na úrovni, kde existuje prostředek, nedošlo k žádné operaci nastavení vlastnosti.The general behavior is as if no property setting operation occurred at the level where the resource exists. Například pokud se pokusíte nastavit pozadí na jednotlivé prvky tlačítka pomocí prostředku, který nebylo možné vyhodnotit, pak se nenastaví žádná hodnota, ale efektivní hodnota může být z jiných účastníků v rámci nastavení systému vlastností a hodnoty.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. Hodnota pozadí může být například stále z lokálně definovaného stylu tlačítka nebo ze stylu motivu.For instance, the background value might still come from a locally defined button style or from the theme style. Pro vlastnosti, které nejsou definovány styly motivů, může platit efektivní hodnota po neúspěšném vyhodnocení prostředku z výchozí hodnoty v metadatech vlastností.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.

OmezeníRestrictions

Odkazy na dynamické prostředky mají určitá významná omezení.Dynamic resource references have some notable restrictions. Alespoň jedna z následujících podmínek musí být pravdivá:At least one of the following conditions must be true:

Vzhledem k tomu, že nastavená vlastnost musí být DependencyProperty Freezable vlastnost nebo, může se většina změn vlastností šířit do uživatelského rozhraní, protože Změna vlastnosti (změněná hodnota dynamického prostředku) je potvrzena systémem vlastností.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. Většina ovládacích prvků zahrnuje logiku, která vynutí jiné rozložení ovládacího prvku, pokud DependencyProperty změny a tato vlastnost mohou ovlivnit rozložení.Most controls include logic that will force another layout of a control if a DependencyProperty changes and that property might affect layout. Nicméně ne všechny vlastnosti, které mají rozšíření značek DynamicResource jako jejich hodnota, jsou zaručeny pro poskytování aktualizací v reálném čase v uživatelském rozhraní.However, not all properties that have a DynamicResource Markup Extension as their value are guaranteed to provide real time updates in the UI. Tato funkce se pořád může lišit v závislosti na vlastnosti, a to v závislosti na typu, který vlastní vlastnost, nebo dokonce na logické struktuře vaší aplikace.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.

Styly, šablony a implicitní klíčeStyles, DataTemplates, and implicit keys

I když všechny položky v ResourceDictionary musí mít klíč, to neznamená, že všechny prostředky musí mít explicitní 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. Několik typů objektů podporuje implicitní klíč, pokud je definován jako prostředek, kde hodnota klíče je svázána s hodnotou jiné vlastnosti.Several object types support an implicit key when defined as a resource, where the key value is tied to the value of another property. Tento typ klíče je známý jako implicitní klíč, zatímco x:Key atribut je explicitní klíč.This type of key is known as an implicit key, whereas an x:Key attribute is an explicit key. Můžete přepsat libovolný implicitní klíč zadáním explicitního klíče.You can overwrite any implicit key by specifying an explicit key.

Jeden z důležitých scénářů pro prostředky je při definování Style .One important scenario for resources is when you define a Style. Ve skutečnosti Style je téměř vždy definováno jako položka ve slovníku prostředků, protože styly jsou podstatně určeny k opakovanému použití.In fact, a Style is almost always defined as an entry in a resource dictionary, because styles are inherently intended for reuse. Další informace o stylech naleznete v tématu stylování and šablonování.For more information about styles, see Styling and Templating.

Styly pro ovládací prvky mohou být vytvořeny pomocí a odkazovány pomocí implicitního klíče.Styles for controls can be both created with and referenced with an implicit key. Styly motivů, které definují výchozí vzhled ovládacího prvku, spoléhají na tento implicitní klíč.The theme styles that define the default appearance of a control rely on this implicit key. Z hlediska vyžádání je implicitní klíč Type samotného ovládacího prvku.From the standpoint of requesting it, the implicit key is the Type of the control itself. Z hlediska definování prostředků je implicitní klíč ve TargetType stylu.From the standpoint of defining the resources, the implicit key is the TargetType of the style. Proto pokud vytváříte motivy pro vlastní ovládací prvky nebo vytváříte styly, které komunikují se stávajícími styly motivů, není pro ni nutné zadávat direktivu 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. A pokud chcete použít styly motivů, nemusíte vůbec zadávat žádný styl.And if you want to use the themed styles, you do not need to specify any style at all. Následující definice stylu například funguje, i když se zdá, že Style prostředek nemá klíč: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>

Tento styl má ve skutečnosti klíč: implicitní klíč typeof(System.Windows.Controls.Button) .That style really does have a key: the implicit key typeof(System.Windows.Controls.Button). V kódu můžete zadat TargetType přímo jako název typu (případně můžete použít {x:Type...} ).In markup, you can specify a TargetType directly as the type name (or you can optionally use {x:Type...} pro vrácení Type .to return a Type.

Pomocí výchozího mechanismu stylu motivu používaného WPF je tento styl použit jako styl modulu runtime Button na stránce, i když se Button sám o sobě nepokusí zadat jeho Style vlastnost nebo konkrétní odkaz na prostředek na styl.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. Váš styl definovaný na stránce se nachází dříve v sekvenci vyhledávání než styl slovníku motivu pomocí stejného klíče, který má styl slovníku motivů.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. Mohli byste jenom zadat <Button>Hello</Button> kamkoli na stránce a styl, který jste definovali, TargetType se Button použije pro toto tlačítko.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. Pokud chcete, můžete stále explicitně klíčovat styl se stejnou hodnotou typu, která TargetType je pro přehlednost v kódu, ale volitelná.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.

Implicitní klíče pro styly neplatí pro ovládací prvek, pokud OverridesDefaultStyle je true .Implicit keys for styles do not apply on a control if OverridesDefaultStyle is true. (Všimněte si také, že OverridesDefaultStyle může být nastaveno jako součást nativního chování pro třídu ovládacího prvku, nikoli explicitně na instanci ovládacího prvku.) Aby bylo možné podporovat implicitní klíče pro odvozené třídy, ovládací prvek musí přepsat DefaultStyleKey (všechny existující ovládací prvky, které jsou součástí WPF jako součást tohoto přepsání).(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). Další informace o stylech, motivech a návrhu ovládacích prvků naleznete v tématu pokyny pro návrh ovládacích ovládacích prvků.For more information about styles, themes, and control design, see Guidelines for Designing Stylable Controls.

DataTemplate má také implicitní klíč.DataTemplate also has an implicit key. Implicitní klíč pro DataTemplate je DataType hodnota vlastnosti.The implicit key for a DataTemplate is the DataType property value. DataType lze také zadat jako název typu místo explicitního použití {x:Type...}.DataType can also be specified as the name of the type rather than explicitly using {x:Type...}. Podrobnosti najdete v tématu Přehled šablonování dat.For details, see Data Templating Overview.

Viz takéSee also