TOC

This article has been localized into Spanish by the community.

Una aplicación WPF:

Manejando excepciones en WPF

Si ya estas familiarizado con C# o algún otro lenguaje .NET que puedes utilizar con WPF, entonces manejar excepciones no debería ser nuevo para ti: Siempre que tienes una sección de código que es muy probable que arroje una excepción, entonces deberías encapsularla en un bloque de try-catch para manejar la excepción satisfactoriamente. Considera el siguiente ejemplo:

private void Button_Click(object sender, RoutedEventArgs e)
{
	string s = null;
	s.Trim();
}

Obviamente no va a funcionar, ya que traté de ejecutar el método Trim() en una variable que actualmente tiene el valor null. Si no manejas la excepción, tu aplicación se romperá y Windows va a tener que lidiar con el problema. Como puedes ver, esto no es muy amigable.

En este caso, el usuario se verá forzado a cerrar tu aplicación, debido a un error tan simple y fácil de evitar. Por lo tanto, si sabes que hay cosas que podrían salir mal, entonces deberías utilizar un bloque try-catch como este:

private void Button_Click(object sender, RoutedEventArgs e)
{
	string s = null;
	try
	{
		s.Trim();
	}
	catch(Exception ex)
	{
		MessageBox.Show("A handled exception just occurred: " + ex.Message, "Exception Sample", MessageBoxButton.OK, MessageBoxImage.Warning);
	}
}

Sin embargo, a veces hasta el código más sencillo puede lanzar una excepción, y en vez de envolver cada línea de código en un bloque try-catch, WPF te deja manejar todas las excepciones no manejadas globalmente. Esto se hace mediante el evento DispatcherUnhandledException en la clase Application. Si te has suscrito, WPF llamará al método suscrito cuando una excepción sea disparada y no haya sido manejada específicamente en tu código. Acá hay un ejemplo completo basado en el asunto que acabamos de ver.

<Window x:Class="WpfTutorialSamples.WPF_Application.ExceptionHandlingSample"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="ExceptionHandlingSample" Height="200" Width="200">
    <Grid>
        <Button HorizontalAlignment="Center" VerticalAlignment="Center" Click="Button_Click">
            Do something bad!
        </Button>
    </Grid>
</Window>
using System;
using System.Windows;

namespace WpfTutorialSamples.WPF_Application
{
	public partial class ExceptionHandlingSample : Window
	{
		public ExceptionHandlingSample()
		{
			InitializeComponent();
		}

		private void Button_Click(object sender, RoutedEventArgs e)
		{
			string s = null;
			try
			{
				s.Trim();
			}
			catch(Exception ex)
			{
				MessageBox.Show("A handled exception just occurred: " + ex.Message, "Exception Sample", MessageBoxButton.OK, MessageBoxImage.Warning);
			}
			s.Trim();
		}
	}
}

Note que llamé al método Trim() una vez más, fuera del bloque try-catch, por lo tanto el primer llamado es manejado, mientras que el segundo no. Para el segundo, necesitamos la magia del App.xaml:

<Application x:Class="WpfTutorialSamples.App"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             DispatcherUnhandledException="Application_DispatcherUnhandledException"
             StartupUri="WPF Application/ExceptionHandlingSample.xaml">
    <Application.Resources>
    </Application.Resources>
</Application>
using System;
using System.Windows;

namespace WpfTutorialSamples
{
	public partial class App : Application
	{
		private void Application_DispatcherUnhandledException(object sender, System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e)
		{
			MessageBox.Show("An unhandled exception just occurred: " + e.Exception.Message, "Exception Sample", MessageBoxButton.OK, MessageBoxImage.Warning);
			e.Handled = true;
		}
	}
}

Manejamos la excepción de forma similar a la local, pero con un ícono y texto un poco diferente en el message box. También nota que puse la propiedad e.Handled en verdadero. Esto le informa a WPF que terminamos con el manejo de la excepción y no se debe realizar nada más al respecto.

Resumen

El manejo de excepciones es una parte muy importante de cualquier aplicación y afortunadamente, WPF y .NET hacen muy fácil el manejo de excepciones tanto local como globalmente. Tu debes manejar las excepciones localmente cuando tiene sentido y sólo hacerlo globalmente como un último recurso, ya que el manejo local permite ser más específico y lidiar con el problema más específicamente.

This article has been fully translated into the following languages: Is your preferred language not on the list? Click here to help us translate this article into your language!