AppDomain.UnhandledException AppDomain.UnhandledException AppDomain.UnhandledException AppDomain.UnhandledException Event

Definizione

Si verifica quando non viene intercettata un'eccezione.Occurs when an exception is not caught.

public:
 virtual event UnhandledExceptionEventHandler ^ UnhandledException;
[add: System.Security.SecurityCritical]
[remove: System.Security.SecurityCritical]
public event UnhandledExceptionEventHandler UnhandledException;
member this.UnhandledException : UnhandledExceptionEventHandler 
Public Custom Event UnhandledException As UnhandledExceptionEventHandler 

Implementazioni

Attributi

Esempi

Nell'esempio seguente viene illustrato il UnhandledException evento.The following example demonstrates the UnhandledException event. Definisce un gestore eventi, MyHandler, che viene richiamato ogni volta che viene generata un'eccezione non gestita nel dominio applicazione predefinito.It defines an event handler, MyHandler, that is invoked whenever an unhandled exception is thrown in the default application domain. Genera quindi le due eccezioni.It then throws two exceptions. Il primo è gestito da un try/catch blocco.The first is handled by a try/catch block. La seconda non viene gestita e richiama il MyHandle routine prima che l'applicazione viene terminata.The second is unhandled and invokes the MyHandle routine before the application terminates.

// The example should be compiled with the /clr:pure compiler option.
using namespace System;
using namespace System::Security::Permissions;

public ref class Example
{


private:
   static void MyHandler(Object^ sender, UnhandledExceptionEventArgs^ args)
   {
      Exception^ e = dynamic_cast<Exception^>(args->ExceptionObject);
      Console::WriteLine( "MyHandler caught : {0}", e->Message );
      Console::WriteLine("Runtime terminating: {0}", args->IsTerminating);
   }
   
public: 
   [SecurityPermissionAttribute( SecurityAction::Demand, ControlAppDomain = true )]
   static void Main()
   {
      AppDomain^ currentDomain = AppDomain::CurrentDomain;
      currentDomain->UnhandledException += gcnew UnhandledExceptionEventHandler(Example::MyHandler);
      try
      {
         throw gcnew Exception("1");
      }
      catch (Exception^ e) 
      {
         Console::WriteLine( "Catch clause caught : {0}\n", e->Message );
      }

      throw gcnew Exception("2");
   }
};

void main()
{
   Example::Main();
}   
// The example displays the following output:
//       Catch clause caught : 1
//       
//       MyHandler caught : 2
//       Runtime terminating: True
//       
//       Unhandled Exception: System.Exception: 2
//          at Example.Main()
//          at mainCRTStartup(String[] arguments)
using System;
using System.Security.Permissions;

public class Example 
{
   [SecurityPermission(SecurityAction.Demand, Flags=SecurityPermissionFlag.ControlAppDomain)]
   public static void Main()
   {
      AppDomain currentDomain = AppDomain.CurrentDomain;
      currentDomain.UnhandledException += new UnhandledExceptionEventHandler(MyHandler);
      
      try {
         throw new Exception("1");
      } catch (Exception e) {
         Console.WriteLine("Catch clause caught : {0} \n", e.Message);
      }

      throw new Exception("2");
   }
   
   static void MyHandler(object sender, UnhandledExceptionEventArgs args) 
   {
      Exception e = (Exception) args.ExceptionObject;
      Console.WriteLine("MyHandler caught : " + e.Message);
      Console.WriteLine("Runtime terminating: {0}", args.IsTerminating);
   }
}
// The example displays the following output:
//       Catch clause caught : 1
//       
//       MyHandler caught : 2
//       Runtime terminating: True
//       
//       Unhandled Exception: System.Exception: 2
//          at Example.Main()  
Module Example
   Sub Main()
      Dim currentDomain As AppDomain = AppDomain.CurrentDomain
      AddHandler currentDomain.UnhandledException, AddressOf MyHandler
      
      Try
         Throw New Exception("1")
      Catch e As Exception
         Console.WriteLine("Catch clause caught : " + e.Message)
         Console.WriteLine()
      End Try
      
      Throw New Exception("2")
   End Sub
   
   Sub MyHandler(sender As Object, args As UnhandledExceptionEventArgs)
      Dim e As Exception = DirectCast(args.ExceptionObject, Exception)
      Console.WriteLine("MyHandler caught : " + e.Message)
      Console.WriteLine("Runtime terminating: {0}", args.IsTerminating)
   End Sub
End Module
' The example displays the following output:
'       Catch clause caught : 1
'       
'       MyHandler caught : 2
'       Runtime terminating: True
'       
'       Unhandled Exception: System.Exception: 2
'          at Example.Main()

Commenti

Questo evento fornisce la notifica delle eccezioni non rilevate.This event provides notification of uncaught exceptions. Consente all'applicazione di registrare le informazioni sull'eccezione prima che il gestore di sistema predefinito segnala all'utente l'eccezione e termina l'applicazione.It allows the application to log information about the exception before the system default handler reports the exception to the user and terminates the application. Se sufficienti informazioni sullo stato dell'applicazione sono disponibile, gli altri si possono intraprendere azioni - ad esempio per salvare i dati del programma per il ripristino di versioni successive.If sufficient information about the state of the application is available, other actions may be undertaken - such as saving program data for later recovery. È consigliabile prestare attenzione, perché i dati del programma possono risultare danneggiati quando le eccezioni non gestite.Caution is advised, because program data can become corrupted when exceptions are not handled.

Nota

Nelle versioni 1.0 e 1.1 di .NET Framework, la terminazione dell'applicazione e le opzioni di debug vengono segnalate all'utente prima che venga generato questo evento, anziché dopo.In the .NET Framework versions 1.0 and 1.1, application termination and debugging options are reported to the user before this event is raised, rather than after.

Questo evento può essere gestito in qualsiasi dominio dell'applicazione.This event can be handled in any application domain. Tuttavia, l'evento non viene necessariamente generato nel dominio dell'applicazione in cui si è verificata l'eccezione.However, the event is not necessarily raised in the application domain where the exception occurred. Un'eccezione viene gestita solo se l'intero stack per il thread è stato rimosso senza trovare un gestore di eccezioni applicabili, in modo che il primo elemento che può essere generato l'evento è nel dominio dell'applicazione in cui il thread ha avuto origine.An exception is unhandled only if the entire stack for the thread has been unwound without finding an applicable exception handler, so the first place the event can be raised is in the application domain where the thread originated.

Nota

Nelle versioni 1.0 e 1.1 di .NET Framework, questo evento si verifica solo per il dominio applicazione predefinito che viene creato dal sistema quando viene avviata un'applicazione.In the .NET Framework versions 1.0 and 1.1, this event occurs only for the default application domain that is created by the system when an application is started. Se un'applicazione crea domini dell'applicazione, specificando un delegato per questo evento in tali domini delle applicazioni non ha alcun effetto.If an application creates additional application domains, specifying a delegate for this event in those applications domains has no effect.

Se il UnhandledException evento viene gestito nel dominio applicazione predefinito, viene generato in per qualsiasi eccezione non gestita in qualsiasi thread, indipendentemente dal dominio applicazione avviato il thread.If the UnhandledException event is handled in the default application domain, it is raised there for any unhandled exception in any thread, no matter what application domain the thread started in. Se il thread avviato in un dominio dell'applicazione che dispone di un gestore eventi per UnhandledException, viene generato l'evento nel dominio dell'applicazione.If the thread started in an application domain that has an event handler for UnhandledException, the event is raised in that application domain. Dominio dell'applicazione non è il dominio applicazione predefinito, se è inoltre disponibile un gestore dell'evento nel dominio applicazione predefinito, l'evento viene generato in entrambi i domini applicazione.If that application domain is not the default application domain, and there is also an event handler in the default application domain, the event is raised in both application domains.

Ad esempio, si supponga che un thread viene avviato dominio dell'applicazione "AD1", chiama un metodo nel dominio dell'applicazione "AD2" e da lì chiama un metodo nel dominio dell'applicazione "AD3", in cui viene generata un'eccezione.For example, suppose a thread starts in application domain "AD1", calls a method in application domain "AD2", and from there calls a method in application domain "AD3", where it throws an exception. Il primo dominio dell'applicazione in cui il UnhandledException evento può essere generato è "AD1".The first application domain in which the UnhandledException event can be raised is "AD1". Se tale dominio dell'applicazione non è il dominio applicazione predefinito, l'evento può essere generato anche nel dominio applicazione predefinito.If that application domain is not the default application domain, the event can also be raised in the default application domain.

Nota

Common language runtime sospende le interruzioni di thread durante i gestori eventi per il UnhandledException eventi sono in esecuzione.The common language runtime suspends thread aborts while event handlers for the UnhandledException event are executing.

Se il gestore di evento include un ReliabilityContractAttribute attributo con il flag appropriato, il gestore dell'evento viene considerato come un'area a esecuzione vincolata.If the event handler has a ReliabilityContractAttribute attribute with the appropriate flags, the event handler is treated as a constrained execution region.

Inizia con la .NET Framework 4.NET Framework 4, questo evento non viene generato per le eccezioni che danneggiano lo stato del processo, ad esempio stack overflow o violazioni di accesso, a meno che il gestore dell'evento è critico per la sicurezza e ha il HandleProcessCorruptedStateExceptionsAttribute attributo.Starting with the .NET Framework 4.NET Framework 4, this event is not raised for exceptions that corrupt the state of the process, such as stack overflows or access violations, unless the event handler is security-critical and has the HandleProcessCorruptedStateExceptionsAttribute attribute.

Nelle versioni 1.0 e 1.1 di .NET Framework, un'eccezione non gestita che si verifica in un thread diverso da quello principale dell'applicazione viene intercettata dal runtime e pertanto non causa l'interruzione dell'applicazione.In the .NET Framework versions 1.0 and 1.1, an unhandled exception that occurs in a thread other than the main application thread is caught by the runtime and therefore does not cause the application to terminate. Di conseguenza, è possibile che il UnhandledException generazione senza terminare l'applicazione dell'evento.Thus, it is possible for the UnhandledException event to be raised without the application terminating. A partire da .NET Framework versione 2.0, questa barriera per le eccezioni non gestite nei thread figlio è stato rimosso, poiché l'effetto cumulativo di tali errori invisibili all'utente inserito una riduzione delle prestazioni, i dati danneggiati e blocchi, ognuno dei quali non è semplice eseguire il debug.Starting with the .NET Framework version 2.0, this backstop for unhandled exceptions in child threads was removed, because the cumulative effect of such silent failures included performance degradation, corrupted data, and lockups, all of which were difficult to debug. Per altre informazioni, incluso un elenco di casi in cui il runtime non viene terminato, vedere eccezioni in thread gestiti.For more information, including a list of cases in which the runtime does not terminate, see Exceptions in Managed Threads.

Per registrare un gestore eventi per questo evento, è necessario disporre delle autorizzazioni necessarie, o un SecurityException viene generata un'eccezione.To register an event handler for this event, you must have the required permissions, or a SecurityException is thrown.

Per ulteriori informazioni sulla gestione degli eventi, consultare gestione e generazione di eventi.For more information about handling events, see Handling and Raising Events.

Altri eventi per le eccezioni non gestiteOther Events for Unhandled Exceptions

Per alcuni modelli di applicazione, il UnhandledException evento può essere superato da altri eventi se si verifica un'eccezione non gestita nel thread principale dell'applicazione.For certain application models, the UnhandledException event can be preempted by other events if the unhandled exception occurs in the main application thread.

Nelle applicazioni che usano Windows Form, eccezioni non gestite nel causa thread principale dell'applicazione di Application.ThreadException generazione dell'evento.In applications that use Windows Forms, unhandled exceptions in the main application thread cause the Application.ThreadException event to be raised. Se questo evento è gestito, il comportamento predefinito prevede che l'eccezione non gestita termina l'applicazione, anche se l'applicazione viene lasciata in uno stato sconosciuto.If this event is handled, the default behavior is that the unhandled exception does not terminate the application, although the application is left in an unknown state. In tal caso, il UnhandledException non viene generato l'evento.In that case, the UnhandledException event is not raised. Questo comportamento può essere modificato usando il file di configurazione dell'applicazione o tramite il Application.SetUnhandledExceptionMode metodo per modificare la modalità a UnhandledExceptionMode.ThrowException prima di ThreadException gestore di evento è associato.This behavior can be changed by using the application configuration file, or by using the Application.SetUnhandledExceptionMode method to change the mode to UnhandledExceptionMode.ThrowException before the ThreadException event handler is hooked up. Questo vale solo per il thread principale dell'applicazione.This applies only to the main application thread. Il UnhandledException evento viene generato per le eccezioni non gestite generate in altri thread.The UnhandledException event is raised for unhandled exceptions thrown in other threads.

A partire da Microsoft Visual Studio 2005, il framework di applicazione Visual Basic fornisce un altro evento per le eccezioni non gestite nel thread principale dell'applicazione.Starting with Microsoft Visual Studio 2005, the Visual Basic application framework provides another event for unhandled exceptions in the main application thread. Vedere il WindowsFormsApplicationBase.UnhandledException evento.See the WindowsFormsApplicationBase.UnhandledException event. Questo evento è un oggetto di argomenti di evento con lo stesso nome dell'oggetto di argomenti di evento utilizzato dal AppDomain.UnhandledException, ma con proprietà diverse.This event has an event arguments object with the same name as the event arguments object used by AppDomain.UnhandledException, but with different properties. In particolare, questo oggetto di argomenti di evento include un ExitApplication proprietà che consente all'applicazione di continuare l'esecuzione, ignorando l'eccezione non gestita (e lasciando l'applicazione in uno stato sconosciuto).In particular, this event arguments object has an ExitApplication property that allows the application to continue running, ignoring the unhandled exception (and leaving the application in an unknown state). In tal caso, il AppDomain.UnhandledException non viene generato l'evento.In that case, the AppDomain.UnhandledException event is not raised.

Sicurezza

SecurityCriticalAttribute
richiede l'attendibilità totale per il chiamante immediato.requires full trust for the immediate caller. Questo membro non può essere utilizzato da codice parzialmente attendibile o trasparente.This member cannot be used by partially trusted or transparent code.

Si applica a