Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto automaticamente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Classe Exception

Rappresenta gli errori che si verificano durante l'esecuzione dell'applicazione.

Spazio dei nomi:  System
Assembly:  mscorlib (in mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
[ClassInterfaceAttribute(ClassInterfaceType.None)]
public class Exception : ISerializable, _Exception

Il tipo Exception espone i seguenti membri.

  NomeDescrizione
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreException()Inizializza una nuova istanza della classe Exception.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreException(String)Inizializza una nuova istanza della classe Exception con un messaggio di errore specificato.
Metodo protettoException(SerializationInfo, StreamingContext)Inizializza una nuova istanza della classe Exception con dati serializzati.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreException(String, Exception)Consente l'inizializzazione di una nuova istanza della classe Exception con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente.
In alto

  NomeDescrizione
Proprietà pubblicaSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreData Ottiene una collezione di coppie chiave/valore che forniscono ulteriori informazioni definite dall'utente sull'eccezione.
Proprietà pubblicaSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreHelpLinkOttiene o imposta un collegamento al file della Guida associato all'eccezione.
Proprietà pubblicaSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreHResult Ottiene o imposta HRESULT, un valore numerico codificato che viene assegnato ad una specifica eccezione.
Proprietà pubblicaSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreInnerExceptionOttiene l'istanza di Exception che ha causato l'eccezione corrente.
Proprietà pubblicaSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreMessageOttiene un messaggio che descrive l'eccezione corrente.
Proprietà pubblicaSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreSourceOttiene o imposta il nome dell'oggetto o dell'applicazione che ha generato l'errore.
Proprietà pubblicaSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreStackTrace Ottiene una rappresentazione in forma di stringa dei frame nello stack di chiamate.
Proprietà pubblicaTargetSite Ottiene il metodo che ha generato l'eccezione corrente.
In alto

  NomeDescrizione
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreEquals(Object) Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
Metodo protettoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreFinalize Consente a un oggetto di provare a liberare risorse ed eseguire altre operazioni di pulizia prima che l'oggetto stesso venga reclamato dalla procedura di Garbage Collection. (Ereditato da Object)
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreGetBaseExceptionSe utilizzato come metodo di override in una classe derivata, restituisce l'Exception che è la causa radice di una o più eccezioni successive.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreGetHashCode Funge da funzione hash per un particolare tipo. (Ereditato da Object)
Metodo pubblicoGetObjectDataQuando l'override viene eseguito in una classe derivata, imposta il controllo SerializationInfo per la colonna.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreGetTypeOttiene il tipo di runtime dell'istanza corrente.

In XNA Framework 3.0 questo membro viene ereditato da Object.GetType().


In Libreria di classi portabile Libreria di classi portabile questo membro viene ereditato da Object.GetType().


In .NET per applicazioni Windows Store Windows 8 questo membro viene ereditato da Object.GetType().
Metodo protettoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreMemberwiseClone Crea una copia dei riferimenti dell'oggetto Object corrente. (Ereditato da Object)
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreToStringCrea e restituisce una rappresentazione in forma di stringa della corrente eccezione. (Esegue l'override di Object.ToString()).
In alto

  NomeDescrizione
Evento protettoSerializeObjectStateSi verifica quando un'eccezione viene serializzata per creare un oggetto stato di eccezione che contiene dati serializzati sull'eccezione.
In alto

Questa classe è la classe base per tutte le eccezioni. Quando si verifica un errore, il sistema o l'applicazione correntemente in esecuzione lo segnala generando un'eccezione che contiene informazioni ad esso relative. Dopo che è stata generata, l'eccezione viene gestita dall'applicazione o dal gestore di eccezioni predefinito.

Contenuto della sezione:

Errori ed eccezioni
Blocchi try/catch
Funzionalità dei tipi di eccezione
Proprietà della classe Exception
Considerazioni sulle prestazioni
Scegliere le eccezioni standard
Implementare eccezioni personalizzate

Errori ed eccezioni

Gli errori di run-time possono verificarsi in diverse situazioni. Comunque, non tutti gli errori devono essere gestiti come eccezioni nel codice. Di seguito sono riportate alcune categorie di errori che possono verificarsi in fase di esecuzione e le modalità appropriate per affrontarli.

  • Errori di utilizzo. Un errore di utilizzo rappresenta un errore nella logica del programma che può generare un'eccezione. Tuttavia, l'errore non deve essere risolto con la gestione di un'eccezione ma modificando il codice errato. Ad esempio, l'override del metodo Object.Equals(Object) nell'esempio seguente presuppone che l'argomento obj debba essere sempre diverso da null.

    
    using System;
    
    public class Person
    {
       private string _name;
    
       public string Name 
       {
          get { return _name; } 
          set { _name = value; }
       }
    
       public override int GetHashCode()
       {
          return this.Name.GetHashCode();  
       }  
    
       public override bool Equals(object obj)
       {
          // This implementation contains an error in program logic:
          // It assumes that the obj argument is not null.
          Person p = (Person) obj;
          return this.Name.Equals(p.Name);
       }
    }
    
    public class Example
    {
       public static void Main()
       {
          Person p1 = new Person();
          p1.Name = "John";
          Person p2 = null; 
    
          // The following throws a NullReferenceException.
          Console.WriteLine("p1 = p2: {0}", p1.Equals(p2));   
       }
    }
    
    
    

    L'eccezione NullReferenceException che si presenta quando obj è null può essere eliminata modificando il codice sorgente in modo da testare in modo esplicito l'uguaglianza a null prima di chiamare l'override di Object.Equals e quindi di ripetere la compilazione. L'esempio seguente contiene il codice sorgente corretto che gestisce un argomento null.

    
    using System;
    
    public class Person
    {
       private string _name;
    
       public string Name 
       {
          get { return _name; } 
          set { _name = value; }
       }
    
       public override int GetHashCode()
       {
          return this.Name.GetHashCode();  
       }  
    
       public override bool Equals(object obj)
       {
           // This implementation handles a null obj argument.
           Person p = obj as Person; 
           if (p == null) 
              return false;
           else
              return this.Name.Equals(p.Name);
       }
    }
    
    public class Example
    {
       public static void Main()
       {
          Person p1 = new Person();
          p1.Name = "John";
          Person p2 = null; 
    
          Console.WriteLine("p1 = p2: {0}", p1.Equals(p2));   
       }
    }
    // The example displays the following output:
    //        p1 = p2: False
    
    
    

    Anziché utilizzare la gestione delle eccezioni per gli errori di utilizzo, è possibile utilizzare il metodo di Debug.Assert per identificare gli errori di utilizzo nelle build di debug e il metodo di Trace.Assert per identificare gli errori di utilizzo e debug che nelle build di rilascio. Per ulteriori informazioni, vedere Asserzioni nel codice gestito.

  • Errori di programma. Un errore di programma è un errore di run-time che non può essere necessariamente evitato scrivendo codice esente da errore.

    In alcuni casi, un errore di programma può riflettere una condizione di errore prevista o di routine. In questo caso, si consiglia di evitare l'utilizzo della gestione delle eccezioni per fronteggiare l'errore di programma e piuttosto di ritentare l'operazione. Ad esempio, se l'utente si aspetta di inserire la data in un particolare formato, è possibile analizzare la stringa della data chiamando il metodo DateTime.TryParseExact, il quale restituisce un valore Boolean che indica se l'operazione di analisi abbia avuto esito positivo, anziché utilizzare il metodo DateTime.ParseExact, che genera un'eccezione FormatException se la stringa della data non può essere convertita in un valore DateTime. Analogamente, se un utente tenta di aprire un file che non esiste, è possibile chiamare prima il metodo File.Exists per controllare che il file esista e, in caso contrario, per richiedere all'utente se desidera crearlo.

    In altri casi, un errore di programma riflette una condizione di errore imprevista che può essere gestita nel codice. Ad esempio, anche se ci si è assicurati che un file esiste, esso potrebbe venire eliminato prima di aprirlo, o esso potrebbe essere corrotto. In tal caso, provare ad aprire il file creando un'istanza di un oggetto StreamReader o chiamando il metodo Open può generare un'eccezione FileNotFoundException. In questi casi, si dovrebbe utilizzare la gestione delle eccezioni per recuperare dall'errore.

  • Errori di sistema. Un errore di sistema è un errore di run-time che non può essere gestito in modo significativo a livello di codice. Ad esempio, un metodo può generare un'eccezione OutOfMemoryException se Common Language Runtime non è in grado di allocare memoria aggiuntiva. In genere, gli errori di sistema non vengono gestiti tramite la gestione delle eccezioni. In alternativa, è possibile utilizzare un evento come AppDomain.UnhandledException e chiamare il metodo Environment.FailFast per registrare le informazioni sulle eccezioni e notificare l'errore all'utente prima che l'applicazione termini.

Blocchi try/catch

Common Language Runtime fornisce un modello di gestione delle eccezioni, basato sulla rappresentazione delle eccezioni come oggetti e sulla separazione del codice di programma e del codice di gestione delle eccezioni in blocchi try e blocchi catch. Possono essere presenti uno o più blocchi catch, ognuno progettato per gestire un particolare tipo di eccezione. In alternativa, può essere presente un blocco creato per intercettare un'eccezione più specifica rispetto a un altro blocco.

Se un'applicazione gestisce le eccezioni che si verificano durante l'esecuzione di un blocco di codice di un'applicazione, il codice deve trovarsi all'interno di un'istruzione try che prende il nome di blocco try. Il codice dell'applicazione che gestisce le eccezioni generate da un blocco try si trova all'interno di un'istruzione catch e viene detto blocco catch. A un blocco try sono associati zero o più blocchi catch e ogni blocco catch include un filtro di tipo che determina i tipi di eccezione che verranno gestiti.

Quando si verifica un'eccezione in un blocco try, viene eseguita la ricerca dei blocchi catch nell'ordine in cui appaiono nel codice dell'applicazione, fino a che non viene individuato un blocco catch che gestisce l'eccezione. Un blocco catch gestisce un'eccezione di tipo T se nel filtro di tipo del blocco catch è specificato T o qualsiasi tipo da cui T deriva. La ricerca viene interrotta dopo il rilevamento del primo blocco catch che gestisce l'eccezione. Per questo motivo, nel codice dell'applicazione, un blocco catch che gestisce un tipo deve essere specificato prima di un blocco catch che gestisce i relativi tipi di base, come dimostrato nell'esempio illustrato di seguito in questa sezione. Un blocco catch che gestisce System.Exception viene specificato per ultimo.

Se nessuno dei blocchi catch associati al blocco try corrente gestisce l'eccezione e se il blocco try corrente è annidato all'interno di altri blocchi try nella chiamata corrente, vengono ricercati i blocchi catch associati al blocco try successivo che li contiene. Se non viene rilevato alcun blocco catch per l'eccezione, viene eseguita la ricerca dei precedenti livelli di annidamento nella chiamata corrente. Se non viene rilevato alcun blocco catch per l'eccezione nella chiamata corrente, l'eccezione viene passata sullo stack di chiamate e viene eseguita la ricerca di un blocco catch che gestisce l'eccezione nello stack frame precedente. La ricerca dello stack di chiamate continua fino a quando viene gestita l'eccezione o non esistono più frame nello stack di chiamate. Se si raggiunge l'inizio dello stack di chiamate senza che venga rilevato alcun blocco catch che gestisce l'eccezione, questa viene gestita dal gestore eccezioni predefinito e l'applicazione viene terminata.

Funzionalità dei tipi di eccezione

I tipi di eccezione supportano le seguenti caratteristiche:

  • Testo in formato leggibile in cui viene descritto l'errore. Quando si verifica un'eccezione, il runtime mette a disposizione un messaggio di testo per informare l'utente della natura dell'errore e per suggerirgli come risolvere il problema. Questo messaggio di testo è contenuto nella proprietà Message dell'oggetto eccezione. Durante la creazione dell'oggetto eccezione, è possibile passare una stringa di testo al costruttore per descrivere i dettagli di quella particolare eccezione. Se al costruttore non viene fornito alcun argomento di messaggio di errore, viene utilizzato il messaggio di errore predefinito. Per ulteriori informazioni, vedere la proprietà Message.

  • Lo stato dello stack di chiamate al momento della generazione dell'eccezione. La proprietà StackTrace riporta una traccia dello stack che può essere utilizzata per determinare il punto del codice in cui si è verificato l'errore. Nella traccia dello stack vengono elencati tutti i metodi chiamati e i numeri di riga nel file di origine dove vengono eseguite le chiamate.

Proprietà della classe Exception

La classe Exception include diverse proprietà in grado di identificare la posizione del codice, il tipo, il file della Guida e il motivo dell'eccezione: StackTrace, InnerException, Message, HelpLink, HResult, Source, TargetSite e Data.

Se esiste una relazione causa-effetto tra due o più eccezioni, la proprietà InnerException mantiene queste informazioni. L'eccezione esterna viene generata in risposta all'eccezione interna. Il codice che gestisce l'eccezione esterna può utilizzare le informazioni relative all'eccezione interna precedente per gestire l'errore in modo più appropriato. Informazioni aggiuntive sull'eccezione possono essere archiviate come una raccolta di coppie chiave/valore nella proprietà Data.

È necessario localizzare la stringa del messaggio di errore passata al costruttore durante la creazione dell'oggetto eccezione e tale messaggio può essere fornito da un file di risorse utilizzando la classe ResourceManager. Per ulteriori informazioni sulle risorse localizzate, vedere gli argomenti Creazione di assembly satellite per applicazioni desktop e Creazione del package e distribuzione delle risorse in applicazioni desktop.

Per fornire all'utente informazioni estese relative alla motivo per cui si è verificata l'eccezione, la proprietà HelpLink può contenere un URL (o URN) di un file della Guida.

La classe Exception utilizza HRESULT COR_E_EXCEPTION, la quale ha il valore 0x80131500.

Per l'elenco dei valori iniziali di proprietà di un'istanza della classe Exception, vedere i costruttori Exception.

Considerazioni sulle prestazioni

Generare o gestire un'eccezione impiega una notevole quantità di risorse del sistema e di tempo di esecuzione. È pertanto consigliabile generare eccezioni solo per gestire condizioni straordinarie e non per gestire eventi prevedibili o per il controllo del flusso. Ad esempio, in alcuni casi, ad esempio quando si sviluppano una libreria di classi, è ragionevole generare un'eccezione se un argomento del metodo non è valido, poiché si prevede che il metodo da chiamare con parametri validi. Un argomento del metodo non valido, se non viene visualizzato a causa di un errore di utilizzo, indica che tutti gli elementi di straordinario si è verificato. Evitare invece la generazione di eccezioni relative a input utente non valido, perché è possibile prevedere che l'utente potrebbe occasionalmente immettere dati non validi. Invece, fornire un meccanismo per far ritentare all'utente l'inserimento di dati di input validi. Non è consigliabile utilizzare le eccezioni per gestire gli errori di utilizzo. Al contrario, utilizzare asserzioni identificare e errori di utilizzo corretto.

Evitare inoltre di generare eccezioni in tutti i casi in cui è sufficiente un codice restituito, non convertire un codice restituito in eccezione e non rilevare regolarmente le eccezioni per poi ignorarle e continuare l'elaborazione.

Scegliere le eccezioni standard

Quando è necessario generare un'eccezione, è spesso possibile utilizzare un tipo di eccezione esistente in .NET Framework anziché implementare un'eccezione personalizzata. Si dovrebbe utilizzare un tipo di eccezione standard in queste due condizioni:

  • Si genera un'eccezione causata da un errore di utilizzo (ovvero da un errore nella logica del programma effettuata dallo sviluppatore che sta chiamando il metodo). In genere, si genererà un'eccezione come ArgumentException, ArgumentNullException, InvalidOperationException o NotSupportedException. La stringa fornita al costruttore dell'oggetto eccezione quando viene creata un'istanza dell'oggetto eccezione dovrebbe descrivere l'errore in modo che lo sviluppatore possa correggerlo. Per ulteriori informazioni, vedere la proprietà Message.

  • Si sta gestendo un errore che può essere notificato al chiamante con un'eccezione esistente di .NET Framework. Si dovrebbe generare l'eccezione più derivata possibile. Ad esempio, se un metodo richiede che un argomento sia un membro valido di un tipo di enumerazione, si dovrebbe generare un'eccezione InvalidEnumArgumentException (la classe più derivata) anziché una ArgumentException.

Implementare eccezioni personalizzate

Nei seguenti casi, non è opportuno usare un'eccezione esistente di .NET Framework per gestire una condizione di errore:

  • Quando l'eccezione riflette un errore di programma univoco che non può essere mappato da un'eccezione esistente di .NET Framework.

  • Quando l'eccezione richiede una gestione diversa dalla quella appropriata per un'eccezione esistente di .NET Framework, o si deve risolvere l'ambiguità dell'eccezione nei confronti di un'altra simile. Ad esempio, se si genera un'eccezione ArgumentOutOfRangeException quando si analizza la rappresentazione numerica di stringa che è al di fuori dell'intervallo del tipo integrale di destinazione, si consiglia di non utilizzare la stessa eccezione per un errore che deriva dal fatto che il chiamante non fornisce i valori vincolati appropriati per la chiamata al metodo.

La classe Exception è la classe base di tutte le eccezioni in .NET Framework. Molte classi derivate si basano sul comportamento ereditato dei membri della classe Exception; essi non eseguono l'override dei membri di Exception, e non definiscono alcun membro univoco.

Per definire una classe di eccezione:

  1. Definire una classe che eredita da Exception. Se necessario, definire i membri aggiuntivi richiesti dalla classe per fornire informazioni aggiuntive sull'eccezione. Ad esempio, la classe ArgumentException include una proprietà ParamName che specifica il nome del parametro il cui argomento ha causato l'eccezione e la proprietà RegexMatchTimeoutException include una proprietà MatchTimeout che indica l'intervallo di timeout.

  2. Se necessario, eseguire l'override dei membri ereditati dei quali si desidera cambiare o modificare le funzionalità. Si noti che la maggior parte delle classi derivate esistenti di Exception non esegue l'override del comportamento dei membri ereditati.

  3. Determinare se l'oggetto eccezione personalizzato è serializzabile. La serializzazione consente di salvare informazioni sull'eccezione e consente alle informazioni sull'eccezione di essere condivise in un contesto remoto da un server e un proxy client. Per rendere l'oggetto eccezione serializzabile, contrassegnarlo con l'attributo SerializableAttribute.

  4. Definire i costruttori della classe di eccezione. In genere, le classi di eccezioni hanno uno o più dei seguenti costruttori:

    • Exception() , che utilizza i valori predefiniti per inizializzare le proprietà di un nuovo oggetto eccezione.

    • Exception(String) , che inizializza un nuovo oggetto eccezione con un messaggio di errore specificato.

    • Exception(String, Exception) , che inizializza un nuovo oggetto eccezione con un messaggio di errore specificato e un'eccezione interna.

    • Exception(SerializationInfo, StreamingContext) , un costruttore di protected che inizializza un nuovo oggetto eccezione da dati serializzati. Si dovrebbe implementare tale costruttore se si è scelto di rendere l'oggetto eccezione serializzabile.

Nell'esempio seguente viene illustrato l'utilizzo di in una classe eccezione personalizzata. Definisce un'eccezione NotPrimeException generata quando un client tenta di recuperare una sequenza di numeri primi specificando un numero iniziale che non è un numero primo. L'eccezione definisce una nuova proprietà, NonPrime, che restituisce il numero non primo che ha causato l'eccezione. Oltre all'implementazione di un costruttore senza parametri protetto e un costruttore con i parametri SerializationInfo e StreamingContext per la serializzazione, la classe NotPrimeException definisce tre costruttori aggiuntivi per supportare la proprietà NonPrime. Ogni costruttore chiama un costruttore di classe base oltre a mantenere il valore del numero non primo. La classe NotPrimeException viene inoltre marcata con l'attributo SerializableAttribute.


using System;
using System.Runtime.Serialization;

[Serializable()]
public class NotPrimeException : Exception
{
   private int notAPrime;

   protected NotPrimeException()
      : base()
   { }

   public NotPrimeException(int value) :
      base(String.Format("{0} is not a prime number.", value))
   {
      notAPrime = value;
   }

   public NotPrimeException(int value, string message)
      : base(message)
   {
      notAPrime = value;
   }

   public NotPrimeException(int value, string message, Exception innerException) :
      base(message, innerException)
   {
      notAPrime = value;
   }

   protected NotPrimeException(SerializationInfo info,
                               StreamingContext context)
      : base(info, context)
   { }

   public int NonPrime
   { get { return notAPrime; } }
}


La classe PrimeNumberGenerator illustrata nell'esempio seguente utilizza il crivello di Eratostene per calcolare la sequenza di numeri primi da 2 fino ad un limite specificato dal client nella chiamata al suo costruttore di classe. Il metodo GetPrimesFrom restituisce tutti i numeri primi maggiori o uguali rispetto ad un limite inferiore specificato, ma genera una NotPrimeException se tale limite inferiore non è un numero primo.


using System;
using System.Collections.Generic;


[Serializable]
public class PrimeNumberGenerator
{
   private const int START = 2;
   private int maxUpperBound = 10000000;
   private int upperBound;
   private bool[] primeTable;
   private List<int> primes = new List<int>();

   public PrimeNumberGenerator(int upperBound)
   {
      if (upperBound > maxUpperBound)
      {
         string message = String.Format(
                           "{0} exceeds the maximum upper bound of {1}.",
                           upperBound, maxUpperBound);
         throw new ArgumentOutOfRangeException(message);
      }
      this.upperBound = upperBound;
      // Create array and mark 0, 1 as not prime (True).
      primeTable = new bool[upperBound + 1];
      primeTable[0] = true;
      primeTable[1] = true;

      // Use Sieve of Eratosthenes to determine prime numbers.
      for (int ctr = START; ctr <= (int)Math.Ceiling(Math.Sqrt(upperBound));
            ctr++)
      {
         if (primeTable[ctr]) continue;

         for (int multiplier = ctr; multiplier <= upperBound / ctr; multiplier++)
            if (ctr * multiplier <= upperBound) primeTable[ctr * multiplier] = true;
      }
      // Populate array with prime number information.
      int index = START;
      while (index != -1)
      {
         index = Array.FindIndex(primeTable, index, (flag) => !flag);
         if (index >= 1)
         {
            primes.Add(index);
            index++;
         }
      }
   }

   public int[] GetAllPrimes()
   {
      return primes.ToArray();
   }

   public int[] GetPrimesFrom(int prime)
   {
      int start = primes.FindIndex((value) => value == prime);
      if (start < 0)
         throw new NotPrimeException(prime, String.Format("{0} is not a prime number.", prime));
      else
         return primes.FindAll((value) => value >= prime).ToArray();
   }
}


Nell'esempio seguente vengono effettuate due chiamate al metodo GetPrimesFrom con numeri non primi, uno dei quali va al di fuori dei limiti del dominio dell'applicazione. In entrambi i casi, viene generata l'eccezione ed essa viene gestita correttamente nel codice client.


using System;
using System.Reflection;

class Example
{
   public static void Main()
   {
      int limit = 10000000;
      PrimeNumberGenerator primes = new PrimeNumberGenerator(limit);
      int start = 1000001;
      try
      {
         int[] values = primes.GetPrimesFrom(start);
         Console.WriteLine("There are {0} prime numbers from {1} to {2}",
                           start, limit);
      }
      catch (NotPrimeException e)
      {
         Console.WriteLine("{0} is not prime", e.NonPrime);
         Console.WriteLine(e);
         Console.WriteLine("--------");
      }

      AppDomain domain = AppDomain.CreateDomain("Domain2");
      PrimeNumberGenerator gen = (PrimeNumberGenerator)domain.CreateInstanceAndUnwrap(
                                        typeof(Example).Assembly.FullName,
                                        "PrimeNumberGenerator", true,
                                        BindingFlags.Default, null,
                                        new object[] { 1000000 }, null, null);
      try
      {
         start = 100;
         Console.WriteLine(gen.GetPrimesFrom(start));
      }
      catch (NotPrimeException e)
      {
         Console.WriteLine("{0} is not prime", e.NonPrime);
         Console.WriteLine(e);
         Console.WriteLine("--------");
      }
   }
}


Il runtime e .NET Framework 4.5.1di windows

In .NET per applicazioni Windows Store per Windows 8, alcune informazioni sull'eccezione in genere vengono perse quando un'eccezione viene propagata dagli stack frame di .NET Framework. A partire da .NET Framework 4.5.1 e Windows 8.1, Common Language Runtime continua a utilizzare l'oggetto originale di Exception generato a meno che tale eccezione è stata modificata in uno stack frame di .NET Framework.

Nel seguente esempio viene illustrato un blocco catch definito per gestire errori ArithmeticException. Questo blocco catch rileva anche errori DivideByZeroException dal momento che DivideByZeroException deriva da ArithmeticException e non esiste alcun blocco catch esplicitamente definito per errori DivideByZeroException.


using System;

class ExceptionTestClass 
{
   public static void Main() 
   {
      int x = 0;
      try 
      {
         int y = 100/x;
      }
         catch (ArithmeticException e) 
         {
            Console.WriteLine("ArithmeticException Handler: {0}", e.ToString());
         }
         catch (Exception e) 
         {
            Console.WriteLine("Generic Exception Handler: {0}", e.ToString());
         }
   }	
}
/*
This code example produces the following results:

ArithmeticException Handler: System.DivideByZeroException: Attempted to divide by zero.
   at ExceptionTestClass.Main()

*/


.NET Framework

Supportato in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Supportato in: 4, 3.5 SP1

Libreria di classi portabile

Supportato in: Libreria di classi portabile

.NET per applicazioni Windows Store

Supportato in: Windows 8

.NET per applicazioni Windows Phone

Supportato in: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (ruoli di base del server non supportati), Windows Server 2008 R2 (ruoli di base del server supportati con SP1 o versione successiva, Itanium non supportato)

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

Qualsiasi membro static (Shared in Visual Basic) pubblico di questo tipo è thread-safe. I membri di istanza non sono garantiti come thread-safe.

System.Object
  System.Exception
    Microsoft.Build.BuildEngine.InternalLoggerException
    Microsoft.Build.BuildEngine.InvalidProjectFileException
    Microsoft.Build.BuildEngine.InvalidToolsetDefinitionException
    Microsoft.Build.BuildEngine.RemoteErrorException
    Microsoft.Build.Exceptions.BuildAbortedException
    Microsoft.Build.Exceptions.InternalLoggerException
    Microsoft.Build.Exceptions.InvalidProjectFileException
    Microsoft.Build.Exceptions.InvalidToolsetDefinitionException
    Microsoft.Build.Framework.LoggerException
    Microsoft.CSharp.RuntimeBinder.RuntimeBinderException
    Microsoft.CSharp.RuntimeBinder.RuntimeBinderInternalCompilerException
    Microsoft.JScript.CmdLineException
    Microsoft.JScript.ParserException
    Microsoft.VisualBasic.ApplicationServices.CantStartSingleInstanceException
    Microsoft.VisualBasic.ApplicationServices.NoStartupFormException
    Microsoft.VisualBasic.Compatibility.VB6.WebClassContainingClassNotOptional
    Microsoft.VisualBasic.Compatibility.VB6.WebClassCouldNotFindEvent
    Microsoft.VisualBasic.Compatibility.VB6.WebClassNextItemCannotBeCurrentWebItem
    Microsoft.VisualBasic.Compatibility.VB6.WebClassNextItemRespondNotFound
    Microsoft.VisualBasic.Compatibility.VB6.WebClassUserWebClassNameNotOptional
    Microsoft.VisualBasic.Compatibility.VB6.WebClassWebClassFileNameNotOptional
    Microsoft.VisualBasic.Compatibility.VB6.WebClassWebItemNotValid
    Microsoft.VisualBasic.Compatibility.VB6.WebItemAssociatedWebClassNotOptional
    Microsoft.VisualBasic.Compatibility.VB6.WebItemClosingTagNotFound
    Microsoft.VisualBasic.Compatibility.VB6.WebItemCouldNotLoadEmbeddedResource
    Microsoft.VisualBasic.Compatibility.VB6.WebItemCouldNotLoadTemplateFile
    Microsoft.VisualBasic.Compatibility.VB6.WebItemNameNotOptional
    Microsoft.VisualBasic.Compatibility.VB6.WebItemNoTemplateSpecified
    Microsoft.VisualBasic.Compatibility.VB6.WebItemTooManyNestedTags
    Microsoft.VisualBasic.Compatibility.VB6.WebItemUnexpectedErrorReadingTemplateFile
    Microsoft.VisualBasic.CompilerServices.IncompleteInitialization
    Microsoft.VisualBasic.CompilerServices.InternalErrorException
    Microsoft.VisualBasic.FileIO.MalformedLineException
    System.Activities.DynamicUpdate.InstanceUpdateException
    System.Activities.ExpressionParser.SourceExpressionException
    System.Activities.Expressions.LambdaSerializationException
    System.Activities.InvalidWorkflowException
    System.Activities.Presentation.Metadata.AttributeTableValidationException
    System.Activities.Statements.WorkflowTerminatedException
    System.Activities.VersionMismatchException
    System.Activities.WorkflowApplicationException
    System.AddIn.Hosting.AddInSegmentDirectoryNotFoundException
    System.AddIn.Hosting.InvalidPipelineStoreException
    System.AggregateException
    System.ApplicationException
    System.ComponentModel.Composition.CompositionContractMismatchException
    System.ComponentModel.Composition.CompositionException
    System.ComponentModel.Composition.ImportCardinalityMismatchException
    System.ComponentModel.Composition.Primitives.ComposablePartException
    System.ComponentModel.DataAnnotations.ValidationException
    System.ComponentModel.Design.ExceptionCollection
    System.Configuration.Provider.ProviderException
    System.Configuration.SettingsPropertyIsReadOnlyException
    System.Configuration.SettingsPropertyNotFoundException
    System.Configuration.SettingsPropertyWrongTypeException
    System.Data.Linq.ChangeConflictException
    System.Diagnostics.Eventing.Reader.EventLogException
    System.Diagnostics.Tracing.EventSourceException
    System.DirectoryServices.ActiveDirectory.ActiveDirectoryObjectExistsException
    System.DirectoryServices.ActiveDirectory.ActiveDirectoryObjectNotFoundException
    System.DirectoryServices.ActiveDirectory.ActiveDirectoryOperationException
    System.DirectoryServices.ActiveDirectory.ActiveDirectoryServerDownException
    System.DirectoryServices.Protocols.DirectoryException
    System.IdentityModel.AsynchronousOperationException
    System.IdentityModel.Metadata.MetadataSerializationException
    System.IdentityModel.Protocols.WSTrust.WSTrustSerializationException
    System.IdentityModel.RequestException
    System.IdentityModel.Selectors.CardSpaceException
    System.IdentityModel.Selectors.IdentityValidationException
    System.IdentityModel.Selectors.PolicyValidationException
    System.IdentityModel.Selectors.ServiceBusyException
    System.IdentityModel.Selectors.ServiceNotStartedException
    System.IdentityModel.Selectors.StsCommunicationException
    System.IdentityModel.Selectors.UnsupportedPolicyOptionsException
    System.IdentityModel.Selectors.UntrustedRecipientException
    System.IdentityModel.Selectors.UserCancellationException
    System.IdentityModel.Services.AsynchronousOperationException
    System.IdentityModel.Services.FederatedAuthenticationSessionEndingException
    System.IdentityModel.Services.FederationException
    System.IdentityModel.Services.WSFederationMessageException
    System.InvalidTimeZoneException
    System.IO.IsolatedStorage.IsolatedStorageException
    System.IO.Log.SequenceFullException
    System.Management.Instrumentation.InstrumentationBaseException
    System.Management.Instrumentation.WmiProviderInstallationException
    System.Net.Http.HttpRequestException
    System.Net.Mail.SmtpException
    System.Net.PeerToPeer.PeerToPeerException
    System.Runtime.CompilerServices.RuntimeWrappedException
    System.Runtime.DurableInstancing.InstancePersistenceException
    System.Runtime.Remoting.MetadataServices.SUDSGeneratorException
    System.Runtime.Remoting.MetadataServices.SUDSParserException
    System.Runtime.Serialization.InvalidDataContractException
    System.Security.RightsManagement.RightsManagementException
    System.ServiceModel.Channels.InvalidChannelBindingException
    System.SystemException
    System.Threading.BarrierPostPhaseException
    System.Threading.LockRecursionException
    System.Threading.Tasks.TaskSchedulerException
    System.TimeZoneNotFoundException
    System.Web.Query.Dynamic.ParseException
    System.Web.Security.MembershipCreateUserException
    System.Web.Security.MembershipPasswordException
    System.Web.UI.ViewStateException
    System.Web.UI.WebControls.EntityDataSourceValidationException
    System.Web.UI.WebControls.LinqDataSourceValidationException
    System.Windows.Automation.NoClickablePointException
    System.Windows.Automation.ProxyAssemblyNotLoadedException
    System.Windows.Controls.PrintDialogException
    System.Windows.Forms.AxHost.InvalidActiveXStateException
    System.Windows.Xps.XpsException
    System.Windows.Xps.XpsWriterException
    System.Workflow.Activities.Rules.RuleException
    System.Workflow.ComponentModel.Compiler.WorkflowValidationFailedException
    System.Workflow.ComponentModel.Serialization.WorkflowMarkupSerializationException
    System.Workflow.ComponentModel.WorkflowTerminatedException
    System.Workflow.Runtime.WorkflowOwnershipException
    System.Xaml.XamlException

Aggiunte alla community

AGGIUNGI
Microsoft sta conducendo un sondaggio in linea per comprendere l'opinione degli utenti in merito al sito Web di MSDN. Se si sceglie di partecipare, quando si lascia il sito Web di MSDN verrà visualizzato il sondaggio in linea.

Si desidera partecipare?
Mostra:
© 2014 Microsoft