WPF - Gestione delle eccezioni

Un'eccezione è una condizione di errore o un comportamento imprevisto riscontrato durante l'esecuzione di un programma. Le eccezioni possono essere sollevate per molte ragioni, alcune delle quali sono le seguenti:

• Errore nel codice o nel codice che chiami (come una libreria condivisa),

• Risorse del sistema operativo non disponibili,

• Condizioni impreviste incontrate da un Common Language Runtime (come codice che non può essere verificato)

Sintassi

Le eccezioni hanno la capacità di trasferire il flusso di un programma da una parte all'altra. In .NET framework, la gestione delle eccezioni ha le seguenti quattro parole chiave:

• try - In questo blocco, il programma identifica una certa condizione che solleva qualche eccezione.

• catch- La parola chiave catch indica la cattura di un'eccezione. UNtry blocco è seguito da uno o più catch blocchi per catturare un'eccezione con un gestore di eccezioni nel punto in un programma in cui si desidera gestire il problema.

• finally- Il blocco finalmente viene utilizzato per eseguire un determinato insieme di istruzioni, indipendentemente dal fatto che venga generata un'eccezione o meno. Ad esempio, se apri un file, deve essere chiuso indipendentemente dal fatto che venga sollevata o meno un'eccezione.

• throw- Un programma genera un'eccezione quando si presenta un problema. Questo viene fatto utilizzando una parola chiave throw.

La sintassi per utilizzare queste quattro parole chiave è la seguente:

try { 
   ///This will still trigger the exception 
} 
catch (ExceptionClassName e) { 
   // error handling code 
} 
catch (ExceptionClassName e) { 
   // error handling code
}
catch (ExceptionClassName e) { 
   // error handling code 
} 
finally { 
   // statements to be executed 
}

Vengono utilizzate più istruzioni catch nei casi in cui un blocco try può sollevare più di un'eccezione a seconda della situazione del flusso di un programma.

Gerarchia

Quasi tutte le classi di eccezione nel framework .NET derivano direttamente o indirettamente dalla classe Exception. Le classi di eccezione più importanti derivate dalla classe Exception sono:

• ApplicationException class- Supporta le eccezioni generate dai programmi. Quando lo sviluppatore desidera definire un'eccezione, la classe dovrebbe essere derivata da questa classe.

• SystemException class- È la classe base per tutte le eccezioni di sistema di runtime predefinite. La seguente gerarchia mostra le eccezioni standard fornite dal runtime.

La tabella seguente elenca le eccezioni standard fornite dal runtime e le condizioni in base alle quali creare una classe derivata.

Tipo di eccezione	Tipo di base	Descrizione
Exception	Oggetto	Classe base per tutte le eccezioni.
SystemException	Eccezione	Classe base per tutti gli errori generati dal runtime.
IndexOutOfRangeException	SystemException	Lanciato dal runtime solo quando un array è indicizzato in modo improprio.
NullReferenceException	SystemException	Generato dal runtime solo quando si fa riferimento a un oggetto null.
AccessViolationException	SystemException	Lanciato dal runtime solo quando si accede a una memoria non valida.
InvalidOperationException	SystemException	Generato dai metodi quando in uno stato non valido.
ArgumentException	SystemException	Classe base per tutte le eccezioni agli argomenti.
ArgumentNullException	ArgumentException	Generato da metodi che non consentono a un argomento di essere nullo.
ArgumentOutOfRangeException	ArgumentException	Generato da metodi che verificano che gli argomenti siano in un determinato intervallo.
ExternalException	SystemException	Classe base per eccezioni che si verificano o sono destinate ad ambienti esterni al runtime.
SEHException	Eccezione esterna	Eccezione che incapsula le informazioni sulla gestione delle eccezioni strutturate Win32.

Esempio

Facciamo un semplice esempio per capire meglio il concetto. Inizia creando un nuovo progetto WPF con il nomeWPFExceptionHandling.

Trascina una casella di testo dalla casella degli strumenti alla finestra di progettazione. Il codice XAML seguente crea una casella di testo e la inizializza con alcune proprietà.

<Window x:Class = "WPFExceptionHandling.MainWindow" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml"
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008"
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   xmlns:local = "clr-namespace:WPFExceptionHandling"
   mc:Ignorable = "d" 
   Title = "MainWindow" Height = "350" Width = "604">
	
   <Grid> 
      <TextBox x:Name = "textBox" HorizontalAlignment = "Left"
         Height = "241" Margin = "70,39,0,0" TextWrapping = "Wrap" 
         VerticalAlignment = "Top" Width = "453"/> 
   </Grid> 
	
</Window>

Ecco la lettura del file con la gestione delle eccezioni in C #.

using System; 
using System.IO; 
using System.Windows;

namespace WPFExceptionHandling { 

   public partial class MainWindow : Window { 
	
      public MainWindow() { 
         InitializeComponent(); 
         ReadFile(0); 
      }
		
      void ReadFile(int index) { 
         string path = @"D:\Test.txt"; 
         StreamReader file = new StreamReader(path); 
         char[] buffer = new char[80]; 
			
         try { 
            file.ReadBlock(buffer, index, buffer.Length); 
            string str = new string(buffer); 
            str.Trim(); 
            textBox.Text = str; 
         }
         catch (Exception e) {
            MessageBox.Show("Error reading from "+ path + "\nMessage = "+ e.Message);
         } 
         finally { 
            if (file != null) { 
               file.Close(); 
            } 
         } 
      } 
   } 
}

Quando compili ed esegui il codice sopra, verrà prodotta la seguente finestra in cui viene visualizzato un testo all'interno della casella di testo.

Quando viene sollevata un'eccezione o viene lanciata manualmente (come nel codice seguente), verrà visualizzata una finestra di messaggio con errore.

using System; 
using System.IO; 
using System.Windows;

namespace WPFExceptionHandling {
 
   public partial class MainWindow : Window {
	
      public MainWindow() { 
         InitializeComponent(); 
         ReadFile(0); 
      } 
		
      void ReadFile(int index) { 
         string path = @"D:\Test.txt"; 
         StreamReader file = new StreamReader(path); 
         char[] buffer = new char[80]; 
			
         try { 
            file.ReadBlock(buffer, index, buffer.Length); 
            string str = new string(buffer); 
            throw new Exception(); 
            str.Trim(); 
            textBox.Text = str; 
         }
         catch (Exception e) { 
            MessageBox.Show("Error reading from "+ path + "\nMessage = "+ e.Message); 
         } 
         finally { 
            if (file != null) { 
               file.Close(); 
            } 
         } 
      } 
   } 
}

Quando viene sollevata un'eccezione durante l'esecuzione del codice precedente, verrà visualizzato il messaggio seguente.

Ti consigliamo di eseguire il codice sopra e di sperimentare con le sue caratteristiche.