Les ressources sont un mécanisme de XAML qui permet de réutiliser facilement des objets ou des valeurs. Chaque classe qui dérive de FrameworkElement dispose d’une propriété Resources, qui est en fait un dictionnaire de ressources. Chaque contrôle peut donc avoir son propre dictionnaire de ressources mais en général, on définit les ressources soit au niveau de la page, soit au niveau de l’application.
Par exemple, pour définir une ressource au niveau de la page, nous utiliserons la syntaxe suivante : Code : XML
<phone:PhoneApplicationPage x:Class="HelloWorld.MainPage"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
[… plein de choses …]
shell:SystemTray.IsVisible="True">
<phone:PhoneApplicationPage.Resources>
<SolidColorBrush x:Key="BrushRouge" Color="Red"/>
</phone:PhoneApplicationPage.Resources>
<[… plein de choses dans la page …]>
</phone:PhoneApplicationPage>
Ici, j’ai créé un objet SolidColorBrush, qui sert à peindre une zone d’une couleur unie, dont la couleur est Rouge dans les ressources de ma page. Il est obligatoire qu’une ressource possède un nom, ici je l’ai nommé BrushRouge.
Je vais désormais pouvoir utiliser cet objet avec des contrôles, ce qui donne : Code : XML
<StackPanel>
<TextBlock Text="Bonjour ma ressource"
Foreground="{StaticResource BrushRouge}" />
<Button Content="Cliquez-moi, je suis rouge"
Foreground="{StaticResource BrushRouge}" />
</StackPanel>
Et nous aurons la figure suivante.
Utilisation d'une ressource de type pinceau rouge
Alors, qu’y-a-t-il derrière ces ressources ?
La première chose que l’on peut voir c’est la syntaxe particulière à l’intérieur de la propriété ForeGround : Code : XML
Foreground="{StaticResource BrushRouge}"
Des accolades avec le mot-clé StaticResource… Cela signifie qu’à l’exécution de l’application, le moteur va aller chercher la ressource associée au nom BrushRouge et il va la mettre dans la propriété Foreground de notre contrôle.
On appelle la syntaxe entre accolades une « extension de balisage XAML », en anglais : extension markup.
Ce moteur commence par chercher la ressource dans les ressources de la page et s’il ne la trouve pas, il ira chercher dans le dictionnaire de ressources de l’application. Nous avons positionné notre ressource dans la page, c’est donc celle-ci qu’il utilise en premier.
Remarquez que le dictionnaire de ressources, c’est simplement une collection d’objets associés à un nom. S’il est défini dans la page, alors il sera accessible pour tous les contrôles de la page. S’il est défini au niveau de l’application, alors il sera utilisable partout dans l’application.
Vous aurez pu constater qu’ici, notre principal intérêt d’utiliser une ressource est de pouvoir changer la couleur de tous les contrôles en une seule fois.
Nous pouvons mettre n’importe quel objet dans les ressources. Nous y avons mis un SolidColorBrush afin que cela se voit, mais il est possible d’y mettre un peu tout et n’importe quoi. Pour illustrer ce point, nous allons utiliser le dictionnaire de
ressource de l’application et y stocker une chaine de caractère. Ouvrez donc le fichier App.xaml où se trouve le dictionnaire de ressources. Nous pouvons ajouter notre chaine de caractères dans la section <Application.Resources> déjà existante pour avoir :
Code : XML
<Application.Resources>
<system:String x:Key="TitreApplication">Hello World</system:String>
</Application.Resources>
Dans le projet créé par défaut pour Windows Phone 8, il y a déjà une ligne dans les ressources de l’application :
<local:LocalizedStrings xmlns:local="clr-namespace:HelloWorld"
x:Key="LocalizedStrings"/> qui fait globalement la même chose, sauf que l’objet mis en ressource est une instance de la classe LocalizedStrings qui se trouve à la racine du projet.
Vous serez obligés de rajouter l’espace de nom suivant en haut du fichier App.xaml : Code : XML
xmlns:system="clr-namespace:System;assembly=mscorlib"
dans les propriétés de l’application de manière à avoir : Code : XML
<Application
x:Class="HelloWorld.App"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"
xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone"
xmlns:system="clr-namespace:System;assembly=mscorlib">
Pourquoi ? Parce que la classe String n’est pas connue de l’application. Il faut lui indiquer où elle se trouve, en indiquant son espace de nom, un peu comme un using C#.
Pour cela on utilise la syntaxe précédente pour dire que l’espace de nom que j’ai nommé « system » correspondra à l’espace de nom System de l’assembly mscorlib.
Pour utiliser ma classe String, il faudra que je la préfixe de « system: ».
Bref, revenons à notre ressource de type String. Je vais pouvoir l’utiliser depuis n’importe quelle page vu qu’elle est définie dans le dictionnaire de ressources de l’application, par exemple dans ma page principale :
Code : XML
<TextBlock Text="{StaticResource TitreApplication}"
Foreground="{StaticResource BrushRouge}" />
Et nous aurons donc la figure suivante.
Utilisation d'une ressource de type chaîne de caractère
Le fichier App.xaml est à l’application ce que le fichier Mainpage.xaml est à la page MainPage. Il est accompagné de son code behind App.xaml.cs et on peut voir que la classe App dérive de la classe Application. Nous y reviendrons mais c’est dans cette classe que nous pourrons gérer tout ce qui rapporte à l’application. C’est le cas par exemple du dictionnaire de ressources, mais c’est également là que nous pourrons gérer les erreurs applicatives non interceptées dans le code et plein d’autres choses que nous découvrirons au fur et à mesure.