Buscar..
Hola Recursos
WPF presenta un concepto muy útil: la capacidad de almacenar datos como un recurso, ya sea localmente para un control, localmente para toda la ventana o globalmente para toda la aplicación. Los datos pueden ser prácticamente lo que desee, desde información real hasta una jerarquía de controles de WPF. Esto le permite colocar datos en un lugar y luego usarlos desde o varios otros lugares, lo cual es muy útil. El concepto se usa mucho para estilos y plantillas.
<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>
Los recursos reciben una clave, utilizando el atributo x: Key, que le permite hacer referencia a él desde otras partes de la aplicación utilizando esta clave, en combinación con la extensión de marcado StaticResource. En este ejemplo, simplemente almaceno una cadena simple, que luego uso de dos controles TextBlock diferentes.
Tipos de recursos
Compartir una cadena simple fue fácil, pero puedes hacer mucho más. En este ejemplo, también almacenaré una gama completa de cadenas, junto con un pincel de degradado que se utilizará para el fondo. Esto debería darle una buena idea de cuánto puede hacer con los recursos:
<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>
Esta vez, hemos agregado un par de recursos adicionales, de modo que nuestra Ventana ahora contiene una cadena simple, una matriz de cadenas y un LinearGradientBrush. La cadena se usa para la etiqueta, la matriz de cadenas se usa como elementos para el control ComboBox y el pincel de degradado se usa como fondo para toda la ventana. Entonces, como puedes ver, casi cualquier cosa puede ser almacenada como un recurso.
Recursos amplios locales y de aplicación
Si solo necesita un recurso determinado para un control específico, puede hacerlo más local agregándolo a este control específico, en lugar de a la ventana. Funciona exactamente de la misma manera, la única diferencia es que ahora solo puede acceder desde el ámbito del control donde lo coloca:
<StackPanel Margin="10">
<StackPanel.Resources>
<sys:String x:Key="ComboBoxTitle">Items:</sys:String>
</StackPanel.Resources>
<Label Content="{StaticResource ComboBoxTitle}" />
</StackPanel>
En este caso, agregamos el recurso al StackPanel y luego lo usamos desde su control secundario, la Etiqueta. Otros controles dentro del StackPanel también podrían haberlo usado, al igual que los niños de estos controles infantiles podrían haber accedido a él. Sin embargo, los controles fuera de este StackPanel en particular no tendrían acceso a él.
Si necesita la posibilidad de acceder al recurso desde varias ventanas, esto también es posible. El archivo App.xaml puede contener recursos como la ventana y cualquier tipo de control WPF, y cuando los almacena en App.xaml, se puede acceder a ellos de forma global en todas las ventanas y controles de usuario del proyecto. Funciona exactamente de la misma manera que cuando se almacena y se usa desde una ventana:
<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>
Usarlo también es lo mismo: WPF subirá automáticamente el alcance, desde el control local a la ventana y luego a App.xaml, para encontrar un recurso determinado:
<Label Content="{StaticResource ComboBoxTitle}" />
Recursos de Code-behind
En este ejemplo, accederemos a tres recursos diferentes de Code-behind, cada uno almacenado en un alcance diferente
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>
Ventana:
<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>
Código detrás:
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());
}
}
}
Entonces, como puedes ver, almacenamos tres "Hola, mundo!" mensajes: uno en App.xaml, uno dentro de la ventana y uno localmente para el panel principal. La interfaz consiste en un botón y un ListBox.
En Code-behind, manejamos el evento de clic del botón, en el que agregamos cada una de las cadenas de texto al ListBox, como se ve en la captura de pantalla. Usamos el método FindResource (), que devolverá el recurso como un objeto (si se encuentra), y luego lo convertimos en la cadena que sabemos que es usando el método ToString ().
Observe cómo utilizamos el método FindResource () en diferentes ámbitos: primero en el panel, luego en la ventana y luego en el objeto Aplicación actual. Tiene sentido buscar el recurso donde sabemos que está, pero como ya se mencionó, si no se encuentra un recurso, la búsqueda avanza hacia la jerarquía, por lo que, en principio, podríamos haber utilizado el método FindResource () en el panel en los tres casos, ya que habría continuado hasta la ventana y luego hasta el nivel de la aplicación, si no se hubiera encontrado.
Lo mismo no ocurre al revés: la búsqueda no navega hacia abajo en el árbol, por lo que no puede comenzar a buscar un recurso en el nivel de la aplicación, si se ha definido localmente para el control o para la ventana.
