C# keyword throw

Nella sezione precedente, abbiamo visto come gestire le eccezioni automaticamente sollevate dal CLR. Ora vedremo come sollevare manualmente un'eccezione.

È possibile sollevare manualmente un'eccezione utilizzando la chiave di parola throw. È possibile sollevare un'eccezione di tipoExceptiondi tipo eccezione derivato da una classe.

static void Main(string[] args)
{
　　　　Student std = null;
　　　　try
　　　　{
　　　　　　　　PrintStudentName(std);
　　　　}
　　　　catch(Exception ex)
　　　　{
　　　　　　　　Console.WriteLine(ex.Message);
　　　　}　　　　　　　　　　　　　　　　　　　　　　
　　　　Console.ReadKey();
}
private static void PrintStudentName(Student std)
{
　　　　if (std == null)
　　　　　　　　throw new NullReferenceException("Oggetto Student null");
　　　　　　　　
　　　　Console.WriteLine(std.StudentName);
}

Oggetto Student null

Nell'esempio sopra, se l'oggetto Student è null, il metodo PrintStudentName() solleva una NullReferenceException.

Notare che throw utilizza la chiave di parola new per creare un oggetto di qualsiasi tipo di eccezione valido. La chiave di parola throw non può essere utilizzata con qualsiasi altro tipo non derivato dalla classe Exception.

Ri-lanciare un'eccezione

È anche possibile ri-lanciare un'eccezione dal blocco catch per trasmetterla al chiamante, in modo che il chiamante possa gestirla nel modo desiderato. L'esempio seguente ri-lancia l'eccezione.

static void Main(string[] args)
{
　　　　try
　　　　{
　　　　　　　　Method1();
　　　　}
　　　　catch(Exception ex)
　　　　{
　　　　　　　　Console.WriteLine(ex.StackTrace);
　　　　}　　　　　　　　　　　　　　　　　　　　　　
}
static void Method1()
{
　　　　try
　　　　{
　　　　　　　　Method2();
　　　　}
　　　　catch(Exception ex)
　　　　{
　　　　　　　　throw;
　　　　}　
}
static void Method2()
{
　　　　string str = null;
　　　　try
　　　　{
　　　　　　　　Console.WriteLine(str[0]);
　　　　}
　　　　catch(Exception ex)
　　　　{
　　　　　　　　throw;
　　　　}　
}

Nell'esempio sopra, si verifica un'eccezione nel Method2(). Il blocco catch utilizza solo la chiave di parola throw (non throw e) per sollevare l'eccezione. Questo viene gestito nel blocco catch di Method1(), dove viene nuovamente sollevata la stessa eccezione, infine gestita nel metodo Main(). La traccia della pila dell'eccezione vi fornirà la posizione esatta e dettagli completi su questa eccezione.

Se si utilizzano parametri di eccezione per lanciare un'eccezione, non verrà mantenuta l'eccezione originale e verrà creata una nuova eccezione. L'esempio seguente ne fornisce una dimostrazione.

static void Main(string[] args)
{
　　　　try
　　　　{
　　　　　　　　Method1();
　　　　}
　　　　catch(Exception ex)
　　　　{
　　　　　　　　Console.WriteLine(ex.StackTrace);
　　　　}　　　　　　　　　　　　　　　　　　　　　　
}
static void Method1()
{
　　　　try
　　　　{
　　　　　　　　Method2();
　　　　}
　　　　catch(Exception ex)
　　　　{
　　　　　　　　throw ex;
　　　　}　
}
static void Method2()
{
　　　　string str = null;
　　　　try
　　　　{
　　　　　　　　Console.WriteLine(str[0]);
　　　　}
　　　　catch(Exception ex)
　　　　{
　　　　　　　　throw;
　　　　}　
}

Nell'esempio sopra, l'eccezione catturata nel metodo Main () mostrerà la traccia della pila di Method1 e Main. Quando usiamo throw ex nel Method1(), non verrà visualizzato Method1 nella traccia della pila. Quindi, non utilizzare mai throw < parameter dell'eccezione > per lanciare un'eccezione.

Scopri come creare un tipo di eccezione personalizzato nel prossimo capitolo.