ResourceDictionary Classe

Définition

Espace de noms:: Microsoft.UI.Xaml

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Modifier

Définit un référentiel pour les ressources XAML, telles que les styles, que votre application utilise. Vous définissez les ressources en XAML, puis vous pouvez les récupérer en XAML à l’aide de l’extension de balisage {StaticResource} et de l’extension de balisage {ThemeResource}. Vous pouvez également accéder aux ressources avec du code, mais cela est moins courant.

/// [Windows.Foundation.Metadata.ContractVersion(Microsoft.UI.Xaml.WinUIContract, 65536)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
class ResourceDictionary : DependencyObject, IIterable<IKeyValuePair<IInspectable, IInspectable const&>>, IMap<IInspectable, IInspectable const&>

[Windows.Foundation.Metadata.ContractVersion(typeof(Microsoft.UI.Xaml.WinUIContract), 65536)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
public class ResourceDictionary : DependencyObject, IDictionary<object,object>, IEnumerable<KeyValuePair<object,object>>

Public Class ResourceDictionary
Inherits DependencyObject
Implements IDictionary(Of Object, Object), IEnumerable(Of KeyValuePair(Of Object, Object))

<ResourceDictionary>
  oneOrMoreResources
</ResourceDictionary>
- or -
<frameworkElement>
  <frameworkElement.Resources>
    oneOrMoreResources
  </frameworkElement.Resources>
</frameworkElement>

Héritage: Object IInspectable DependencyObject ResourceDictionary

Dérivé: Microsoft.UI.Xaml.ColorPaletteResources

Microsoft.UI.Xaml.Controls.XamlControlsResources

Attributs: ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Implémente: IDictionary<Object,Object> IMap<IInspectable,IInspectable> IIterable<IKeyValuePair<K,V>> IEnumerable<KeyValuePair<K,V>> IEnumerable<KeyValuePair<Object,Object>> IIterable<IKeyValuePair<IInspectable,IInspectable>>

Remarques

Un dictionnaire de ressources est un référentiel pour les ressources XAML, telles que les styles, que votre application utilise. Vous définissez les ressources en XAML, puis vous pouvez les récupérer en XAML à l’aide de l’extension de balisage {StaticResource} et de l’extension de balisage {ThemeResource}. Vous pouvez également accéder aux ressources avec du code, mais cela est moins courant. Vous pouvez utiliser des ressources pour appliquer que certaines valeurs telles que les couleurs de pinceau ou les mesures de pixels sont utilisées de manière cohérente dans toute votre application. Pour plus d’informations sur l’utilisation efficace des dictionnaires de ressources, consultez les références de ressources ResourceDictionary et XAML.

Utilisations d’éléments ResourceDictionary

Le ResourceDictionary type est utilisé comme valeur de deux propriétés, FrameworkElement.Resources et Application.Resources, qui sont importantes pour la structure globale d’une application SDK d'application Windows. Les fichiers XAML que vous obtenez à partir d’un modèle de projet de démarrage pour une application commencent par des valeurs initiales pour FrameworkElement.Resources, et le fichier app.xaml peut commencer par des valeurs initiales pour Application.Resources. Exactement quelles ressources sont définies il dépend du modèle de démarrage du projet que vous utilisez.

Ce code XAML montre l’utilisation d’une propriété FrameworkElement.Resources . Dans ce cas, FrameworkElement est une page. Il n’existe aucun ResourceDictionary élément subordonné à l’élément de propriété, mais sa présence est implicite. Pour plus d’informations, consultez la section « Notes sur la Page.Resources syntaxe XAML » ci-dessous. Le code XAML place un style dans l’objet ResourceDictionary avec une valeur d’attribut x :Key de « TextBlockStyle1 ». Plus loin dans le code XAML, l’extension de balisage {StaticResource} fait référence Style au dictionnaire de ressources pour fournir une valeur pour la propriété Style de l’élément TextBlock .

Le style comme indiqué n’applique pas réellement de style au TextBlock, mais vous pouvez ajouter Style des propriétés dans Microsoft Visual Studio. Vous pouvez ensuite utiliser la Style ressource aussi souvent que vous le souhaitez sur la page pour appliquer l’uniformité.

<Page
    x:Class="ResourceDictionary_example.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:ResourceDictionary_example"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">
    <Page.Resources>
        <Style x:Key="TextBlockStyle1" TargetType="TextBlock"/>
    </Page.Resources>

    <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
        <TextBlock Style="{StaticResource TextBlockStyle1}" Text="TextBlock"/>
    </Grid>
</Page>

Ce code XAML, à partir du fichier AppPage.xaml de l’exemple AtomPub, montre l’utilisation d’une propriété Application.Resources . Le code XAML place deux éléments style dans le dictionnaire de ressources, les rendant disponibles dans l’application.

<Application xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    x:Class="AtomPub.App"
    RequestedTheme="Light" >
    <Application.Resources>
        <ResourceDictionary>
            <Style x:Key="TitleStyle" TargetType="TextBlock">
                <Setter Property="Foreground" Value="#707070"/>
                <Setter Property="FontFamily" Value="Segoe UI Light"/>
                <Setter Property="FontSize" Value="16"/>
            </Style>
            <Style x:Key="H1Style" TargetType="TextBlock">
                <Setter Property="Foreground" Value="#212121"/>
                <Setter Property="FontFamily" Value="Segoe UI Semilight"/>
                <Setter Property="FontSize" Value="26.667"/>
                <Setter Property="Margin" Value="0,0,0,25"/>
            </Style>
            ...
        </ResourceDictionary>
    </Application.Resources>
</Application>

Ce code XAML à partir du fichier MainPage.xaml utilise l’extension de balisage {StaticResource} pour accéder aux styles TitleStyle et H1Style :

...
<!-- Header -->
<StackPanel x:Name="Header" Grid.Row="0">
    <StackPanel Orientation="Horizontal">
        ...
        <TextBlock Text="Windows SDK Samples" VerticalAlignment="Bottom" Style="{StaticResource TitleStyle}" TextWrapping="Wrap"/>
    </StackPanel>
    <TextBlock x:Name="FeatureName" Text="Add Feature Name" Style="{StaticResource H1Style}" TextWrapping="Wrap"/>
</StackPanel>
 ...

Vous pouvez factoriser les ressources dans leur propre fichier XAML à l’aide de ResourceDictionary comme élément racine du fichier. Vous pouvez ensuite inclure ces ressources dans un dictionnaire de ressources FrameworkElement.Resources ou Application.Resources . Pour ce faire, utilisez la propriété ResourceDictionary.MergedDictionaries ou la propriété ResourceDictionary.ThemeDictionaries de l’élément ResourceDictionary.

Ce fichier, Common/Styles1.xaml, définit les ressources style à l’aide ResourceDictionary de l’élément racine :

<ResourceDictionary
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

    <Style x:Key="TitleTextStyle" TargetType="TextBlock">
        <Setter Property="FontFamily" Value="Segoe UI Light"/>
        <Setter Property="FontSize" Value="16"/>
    </Style>
    <Style x:Key="HeaderTextStyle" TargetType="TextBlock">
        <Setter Property="FontFamily" Value="Segoe UI Semilight"/>
        <Setter Property="FontSize" Value="26.667"/>
        <Setter Property="Margin" Value="0,0,0,25"/>
    </Style>
    ...
</ResourceDictionary>

Supposons maintenant qu’il existe un autre fichier, Common/Styles2.xaml qui définit de même les ressources style . Ce code XAML montre comment fusionner les ressources dans ces deux fichiers à l’aide de la propriété ResourceDictionary.MergeDictionaries pour créer un dictionnaire de ressources Application.Resources . Le code XAML définit également deux autres ressources de style et les fusionne avec les ressources des deux fichiers.

<Application
    .... >
    <Application.Resources>
        <ResourceDictionary>
            <Style x:Key="ErrorStyle" TargetType="TextBlock">
                <Setter Property="Foreground" Value="DarkRed"/>
                <Setter Property="FontFamily" Value="Segoe UI Semilight"/>
                <Setter Property="FontSize" Value="15"/>
            </Style>
            <Style x:Key="StatusStyle" TargetType="TextBlock">
                <Setter Property="Foreground" Value="Black"/>
                <Setter Property="FontFamily" Value="Segoe UI Semilight"/>
                <Setter Property="FontSize" Value="15"/>
            </Style>
            <ResourceDictionary.MergedDictionaries>
                <!-- 
                    Styles that define common aspects of the platform look and feel
                 -->
                <ResourceDictionary Source="Common/Styles1.xaml"/>
                <ResourceDictionary Source="Common/Styles2.xaml"/>
            </ResourceDictionary.MergedDictionaries>
        </ResourceDictionary>
    </Application.Resources>
</Application>

Pour plus d’informations sur la résolution des ressources de dictionnaire fusionnées, consultez la section « Dictionnaires de ressources fusionnés » des références de ressources ResourceDictionary et XAML.

Propriété x :Key

En XAML, les clés des ResourceDictionary éléments sont déclarées en définissant l’attribut x :Keysur les éléments qui représentent les ressources XAML. En règle générale, si vous essayez de placer un élément enfant qui n’a pas de valeur de clé dans un ResourceDictionary, cela lève une exception d’analyse XAML ou une exception Windows Runtime. La condition d’exception peut également être notée comme un avertissement par les surfaces de conception XAML. Toutefois, il existe trois cas notables où un ResourceDictionary élément enfant ne nécessite pas de valeur d’attribut x :Key :

Une ressource Style peut utiliser sa valeur TargetType comme clé de ressource implicite. Pour plus d’informations sur le fonctionnement des clés implicites pour les styles et les modèles de contrôle, consultez Contrôles de style.
Les éléments avec des ResourceDictionary valeurs sources qui représentent les valeurs ResourceDictionary.MergedDictionaries ne peuvent pas avoir d’attribut x :Key sur ResourceDictionary. Dans chaque fichier de dictionnaire fusionné( celui référencé par URI comme source), vous avez besoin de clés pour chaque ressource.
L’attribut x :Name peut être utilisé au lieu de l’attribut x :Key, pour des raisons héritées. Toutefois, l’attribut x :Name lui-même n’active pas la recherche de ressources XAML de cet élément. La convention d’identification de l’attribut x :Name est utilisée pour certains scénarios, tels que la définition d’animations storyboarded. Pour plus d’informations, consultez l’attribut x :Name.

Itération via un ResourceDictionary

Vous pouvez effectuer une itération au sein d’un ResourceDictionary C#. Dans de nombreux cas, comme l’utilisation foreach de la syntaxe, le compilateur effectue ce cast pour vous et vous n’aurez pas besoin de effectuer un cast IEnumerable de manière explicite. Si vous devez effectuer un cast explicite, par exemple si vous souhaitez appeler GetEnumerator, effectuez un cast vers IEnumerable<T> avec une KeyValuePair<Object,Object> contrainte.

ResourceDictionary et Microsoft Visual Studio

Microsoft Visual Studio fournit un choix de page Ajouter un nouvel élément pour un dictionnaire de ressources. Utilisez cette option chaque fois que vous souhaitez définir un nouveau dictionnaire de ressources XAML libre, par exemple pour servir de source pour un dictionnaire fusionné. Microsoft Visual Studio ajoute également un dictionnaire de ressources XAML libre au projet chaque fois que vous utilisez Ajouter un nouvel élément pour créer un contrôle modèle. Ce dictionnaire de ressources fournit les modèles de thème par défaut. Microsoft Visual Studio pouvez créer une nouvelle ResourceDictionary version pour vous dans votre code XAML si vous modifiez des copies de styles ou de modèles et une ResourceDictionary pour votre emplacement de ressource choisi (application, page ou autonome) n'existe pas encore.

Remarques sur la syntaxe XAML

Notez que la syntaxe de collection implicite XAML pour ResourceDictionary n’inclut pas d’élément objet pour le ResourceDictionary. Il s’agit d’un exemple de syntaxe de collection implicite XAML ; une balise représentant l’élément de collection peut être omise. Les éléments ajoutés en tant qu’éléments à la collection sont spécifiés en tant qu’éléments enfants d’un élément de propriété d’une propriété dont le type sous-jacent prend en charge un dictionnaire / map Add, méthode.

Pour un dictionnaire de ressources fusionné, vous devez déclarer explicitement un ResourceDictionary élément objet afin de pouvoir également déclarer l’élément de propriété ResourceDictionary.MergedDictionaries et Source. Par conséquent, il existe au moins deux ResourceDictionary éléments d’objet impliqués, et vous utilisez cette syntaxe.

<ResourceDictionary>
  <ResourceDictionary.MergedDictionaries>
    <ResourceDictionary Source="uri"/>
    ...
  </ResourceDictionary.MergedDictionaries>
...
</ResourceDictionary>

Dans cette syntaxe, l’extérieur ResourceDictionary est le principal ResourceDictionary. L’intérieur ResourceDictionary est le ResourceDictionary fusion.

Pour l’utilisation implicite de la collection, l’espace réservé approprié pour la propriété FrameworkElement.Resources s’affiche. Vous pouvez également utiliser cette utilisation implicite de collection pour la propriété Application.Resources , ou potentiellement pour une propriété personnalisée qui utilise ResourceDictionary comme type de propriété.

Types partageables et types UIElement

Un dictionnaire de ressources est une technique permettant de définir des types et des valeurs partageables de ces types en XAML. Tous les types ou valeurs ne conviennent pas à l’utilisation d’un ResourceDictionary. Exemples de types où le partage est pris en charge incluent style, n’importe quelle sous-classe FrameworkTemplate , les types de données intrinsèques XAML, les pinceaux, les couleurs et les transformations. Pour plus d’informations sur les types considérés comme partageables, consultez les références de ressources ResourceDictionary et XAML. En règle générale, les types dérivés d’UIElement ne sont pas partageables, sauf s’ils proviennent de modèles et d’application d’un modèle sur une instance de contrôle spécifique. À l’exception du cas de modèle, un UIElement est censé exister dans un seul emplacement dans une arborescence d’objets après son instanciation et avoir un UIElement pouvant être partagé serait potentiellement enfreint ce principe.

Dans la pratique, la grande majorité des ressources définies dans un sera l’une ResourceDictionary des suivantes :

Modèles de contrôle pour un contrôle, y compris ses états visuels.
Prise en charge des styles pour les parties des contrôles
Styles pour les éléments qui font partie de l’interface utilisateur d’application classique, mais qui ne sont pas des contrôles, comme TextBlock
Modèles de données pour les contrôles et les panneaux qui utilisent la liaison de données
Valeurs de pinceau spécifiques, principalement SolidColorBrush
Chaînes ou autres constantes qui n’ont jamais besoin d’être localisées (chaînes et constantes qui doivent être localisées ne doivent pas se trouver dans un ResourceDictionary ; pour plus d’informations, voir Démarrage rapide : Traduire des ressources d’interface utilisateur)

Accès à un objet ResourceDictionary dans le code

L’API utilisée par votre code pour accéder aux ressources d’un ResourceDictionary dépend du langage de programmation que vous utilisez :

Pour C#, vous utilisez l’API qui implémente IDictionary<TKey, TValue> et IEnumerable<T>. Par exemple, TryGetValue ou l’indexeur Item .
L’API qui ne fait pas partie de la prise en charge des collections, comme Source, est identique dans toutes les langues.

Pour plus d’informations sur l’utilisation ResourceDictionary dans le code, consultez la section « Utilisation d’un ResourceDictionary à partir du code » des références de ressources ResourceDictionary et XAML.

Ressources système

Certaines ressources de thème référencent les valeurs de ressources système en tant que sous-valeur sous-jacente. Une ressource système est une valeur de ressource spéciale qui n’est trouvée dans aucun dictionnaire de ressources XAML. Ces valeurs s’appuient sur le comportement dans la prise en charge XAML de Windows Runtime pour transférer les valeurs du système lui-même et les représenter sous la forme qu’une ressource XAML peut référencer.

Constructeurs

Nom	Description
ResourceDictionary()	Initialise une nouvelle instance de la classe ResourceDictionary .

Propriétés

Nom	Description
Dispatcher	Retourne `null` toujours dans une application du Kit de développement logiciel (SDK) d’application Windows. Utilisez DispatcherQueue à la place. (Hérité de DependencyObject)
DispatcherQueue	Obtient le `DispatcherQueue` résultat auquel cet objet est associé. Représente `DispatcherQueue` une installation qui peut accéder au `DependencyObject` thread d’interface utilisateur même si le code est initié par un thread non-interface utilisateur. (Hérité de DependencyObject)
MergedDictionaries	Obtient une collection des dictionnaires ResourceDictionary qui constituent les différents dictionnaires de ressources dans les dictionnaires fusionnés.
Size	Obtient le nombre d’éléments contenus dans la collection.
Source	Obtient ou définit un URI (Uniform Resource Identifier) qui fournit l’emplacement source d’un dictionnaire de ressources fusionné.
ThemeDictionaries	Obtient une collection de dictionnaires de ressources fusionnés qui sont spécifiquement clés et composés pour traiter les scénarios de thème, par exemple en fournissant des valeurs de thème pour « HighContrast ».

Méthodes

Nom	Description
Clear()	Supprime tous les éléments de ce ResourceDictionary.
ClearValue(DependencyProperty)	Efface la valeur locale d’une propriété de dépendance. (Hérité de DependencyObject)
First()	Retourne un itérateur pour les éléments de la collection.
GetAnimationBaseValue(DependencyProperty)	Retourne toute valeur de base établie pour une propriété de dépendance, qui s’applique dans les cas où une animation n’est pas active. (Hérité de DependencyObject)
GetValue(DependencyProperty)	Retourne la valeur effective actuelle d’une propriété de dépendance à partir d’un DependencyObject. (Hérité de DependencyObject)
GetView()	Récupère une vue sur ResourceDictionary.
HasKey(Object)	Retourne si ResourceDictionary a une entrée avec la clé demandée.
Insert(Object, Object)	Ajoute une nouvelle entrée à ResourceDictionary.
Lookup(Object)	Retourne la valeur de la clé demandée, si une entrée avec cette clé existe.
ReadLocalValue(DependencyProperty)	Retourne la valeur locale d’une propriété de dépendance, si une valeur locale est définie. (Hérité de DependencyObject)
RegisterPropertyChangedCallback(DependencyProperty, DependencyPropertyChangedCallback)	Inscrit une fonction de notification pour écouter les modifications apportées à une dependencyProperty spécifique sur cette instance DependencyObject . (Hérité de DependencyObject)
Remove(Object)	Supprime un élément spécifique de ResourceDictionary.
SetValue(DependencyProperty, Object)	Définit la valeur locale d’une propriété de dépendance sur un DependencyObject. (Hérité de DependencyObject)
UnregisterPropertyChangedCallback(DependencyProperty, Int64)	Annule une notification de modification qui a été précédemment inscrite en appelant RegisterPropertyChangedCallback. (Hérité de DependencyObject)

S’applique à

Voir aussi

Commentaires

Cette page a-t-elle été utile ?