Recherche…
Bonjour ressources
WPF introduit un concept très pratique: possibilité de stocker des données en tant que ressource, localement pour un contrôle, localement pour la fenêtre entière ou globalement pour l'application entière. Les données peuvent être à peu près ce que vous voulez, des informations réelles à une hiérarchie de contrôles WPF. Cela vous permet de placer des données à un endroit et de les utiliser à partir de plusieurs autres endroits, ce qui est très utile. Le concept est beaucoup utilisé pour les styles et les modèles.
<Window x:Class="WPFApplication.ResourceSample"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:sys="clr-namespace:System;assembly=mscorlib"
Title="ResourceSample" Height="150" Width="350">
<Window.Resources>
<sys:String x:Key="strHelloWorld">Hello, world!</sys:String>
</Window.Resources>
<StackPanel Margin="10">
<TextBlock Text="{StaticResource strHelloWorld}" FontSize="56" />
<TextBlock>Just another "<TextBlock Text="{StaticResource strHelloWorld}" />" example, but with resources!</TextBlock>
</StackPanel>
</Window>
Les ressources reçoivent une clé, en utilisant l'attribut x: Key, qui vous permet de le référencer à partir d'autres parties de l'application en utilisant cette clé, en combinaison avec l'extension de balisage StaticResource. Dans cet exemple, je stocke simplement une chaîne simple, que j'utilise ensuite à partir de deux contrôles TextBlock différents.
Types de ressources
Partager une chaîne simple était facile, mais vous pouvez faire beaucoup plus. Dans cet exemple, je vais également stocker un tableau complet de chaînes, ainsi qu'un pinceau de dégradé à utiliser pour l'arrière-plan. Cela devrait vous donner une bonne idée de ce que vous pouvez faire avec les ressources:
<Window x:Class="WPFApplication.ExtendedResourceSample"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:sys="clr-namespace:System;assembly=mscorlib"
Title="ExtendedResourceSample" Height="160" Width="300"
Background="{DynamicResource WindowBackgroundBrush}">
<Window.Resources>
<sys:String x:Key="ComboBoxTitle">Items:</sys:String>
<x:Array x:Key="ComboBoxItems" Type="sys:String">
<sys:String>Item #1</sys:String>
<sys:String>Item #2</sys:String>
<sys:String>Item #3</sys:String>
</x:Array>
<LinearGradientBrush x:Key="WindowBackgroundBrush">
<GradientStop Offset="0" Color="Silver"/>
<GradientStop Offset="1" Color="Gray"/>
</LinearGradientBrush>
</Window.Resources>
<StackPanel Margin="10">
<Label Content="{StaticResource ComboBoxTitle}" />
<ComboBox ItemsSource="{StaticResource ComboBoxItems}" />
</StackPanel>
</Window>
Cette fois, nous avons ajouté quelques ressources supplémentaires, de sorte que notre fenêtre contient maintenant une chaîne simple, un tableau de chaînes et un LinearGradientBrush. La chaîne est utilisée pour l'étiquette, le tableau de chaînes est utilisé comme éléments pour le contrôle ComboBox et le pinceau dégradé est utilisé comme arrière-plan pour la fenêtre entière. Ainsi, comme vous pouvez le voir, pratiquement tout peut être stocké en tant que ressource.
Ressources locales et applicatives
Si vous avez uniquement besoin d'une ressource donnée pour un contrôle spécifique, vous pouvez la rendre plus locale en l'ajoutant à ce contrôle spécifique, au lieu de la fenêtre. Cela fonctionne exactement de la même manière, la seule différence étant que vous ne pouvez désormais accéder qu'à partir de la portée du contrôle où vous l'avez placé:
<StackPanel Margin="10">
<StackPanel.Resources>
<sys:String x:Key="ComboBoxTitle">Items:</sys:String>
</StackPanel.Resources>
<Label Content="{StaticResource ComboBoxTitle}" />
</StackPanel>
Dans ce cas, nous ajoutons la ressource au StackPanel, puis l'utilisons depuis son contrôle enfant, le Label. D'autres contrôles à l'intérieur du StackPanel auraient pu l'utiliser aussi, tout comme les enfants de ces contrôles enfants auraient pu y accéder. Les contrôles en dehors de ce StackPanel particulier n'y auraient pas accès.
Si vous avez besoin de la possibilité d'accéder à la ressource à partir de plusieurs fenêtres, cela est également possible. Le fichier App.xaml peut contenir des ressources comme la fenêtre et tout type de contrôle WPF. Lorsque vous les stockez dans App.xaml, ils sont globalement accessibles dans toutes les fenêtres et les contrôles utilisateur du projet. Cela fonctionne exactement comme lors du stockage et de l'utilisation d'une fenêtre:
<Application x:Class="WpfSamples.App"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:sys="clr-namespace:System;assembly=mscorlib"
StartupUri="WPFApplication/ExtendedResourceSample.xaml">
<Application.Resources>
<sys:String x:Key="ComboBoxTitle">Items:</sys:String>
</Application.Resources>
</Application>
En l’utilisant également, WPF monte automatiquement la portée, du contrôle local à la fenêtre puis à App.xaml, pour trouver une ressource donnée:
<Label Content="{StaticResource ComboBoxTitle}" />
Ressources de Code-behind
Dans cet exemple, nous accédons à trois ressources différentes de Code-behind, chacune stockée dans une portée différente.
App.xaml:
<Application x:Class="WpfSamples.App"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:sys="clr-namespace:System;assembly=mscorlib"
StartupUri="WPFApplication/ResourcesFromCodeBehindSample.xaml">
<Application.Resources>
<sys:String x:Key="strApp">Hello, Application world!</sys:String>
</Application.Resources>
</Application>
Fenêtre:
<Window x:Class="WpfSamples.WPFApplication.ResourcesFromCodeBehindSample"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:sys="clr-namespace:System;assembly=mscorlib"
Title="ResourcesFromCodeBehindSample" Height="175" Width="250">
<Window.Resources>
<sys:String x:Key="strWindow">Hello, Window world!</sys:String>
</Window.Resources>
<DockPanel Margin="10" Name="pnlMain">
<DockPanel.Resources>
<sys:String x:Key="strPanel">Hello, Panel world!</sys:String>
</DockPanel.Resources>
<WrapPanel DockPanel.Dock="Top" HorizontalAlignment="Center" Margin="10">
<Button Name="btnClickMe" Click="btnClickMe_Click">Click me!</Button>
</WrapPanel>
<ListBox Name="lbResult" />
</DockPanel>
</Window>
Code-behind:
using System;
using System.Windows;
namespace WpfSamples.WPFApplication
{
public partial class ResourcesFromCodeBehindSample : Window
{
public ResourcesFromCodeBehindSample()
{
InitializeComponent();
}
private void btnClickMe_Click(object sender, RoutedEventArgs e)
{
lbResult.Items.Add(pnlMain.FindResource("strPanel").ToString());
lbResult.Items.Add(this.FindResource("strWindow").ToString());
lbResult.Items.Add(Application.Current.FindResource("strApp").ToString());
}
}
}
Donc, comme vous pouvez le voir, nous stockons trois différents "Hello, world!" messages: un dans App.xaml, un dans la fenêtre et un autre pour le panneau principal. L'interface est composée d'un bouton et d'une ListBox.
Dans Code-behind, nous gérons l'événement click du bouton, dans lequel nous ajoutons chacune des chaînes de texte au contrôle ListBox, comme le montre la capture d'écran. Nous utilisons la méthode FindResource (), qui retournera la ressource en tant qu'objet (si elle est trouvée), puis nous la transformons en chaîne que nous connaissons en utilisant la méthode ToString ().
Remarquez comment nous utilisons la méthode FindResource () sur différentes étendues - d'abord sur le panneau, puis sur la fenêtre, puis sur l'objet Application actuel. Il est logique de rechercher la ressource à sa connaissance, mais, comme nous l’avons déjà mentionné, si une ressource n’est pas trouvée, la recherche progresse dans la hiérarchie. En principe, nous aurions pu utiliser la méthode FindResource () sur le panneau tous les trois cas, car il aurait continué jusqu'à la fenêtre et plus tard au niveau de l'application, si non trouvé.
La même chose n'est pas vraie dans l'autre sens: la recherche ne navigue pas dans l'arborescence. Vous ne pouvez donc pas rechercher une ressource au niveau de l'application, si elle a été définie localement pour le contrôle ou pour la fenêtre.