AppDomain.UnhandledException Zdarzenie

Definicja

Występuje, gdy wyjątek nie zostanie przechwycony.Occurs when an exception is not caught.

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

Typ zdarzenia

UnhandledExceptionEventHandler

Implementuje

Atrybuty

Przykłady

Poniższy przykład demonstruje UnhandledException zdarzenie.The following example demonstrates the UnhandledException event. Definiuje procedurę obsługi zdarzeń, MyHandler która jest wywoływana za każdym razem, gdy w domenie aplikacji domyślnej zostanie zgłoszony nieobsługiwany wyjątek.It defines an event handler, MyHandler, that is invoked whenever an unhandled exception is thrown in the default application domain. Następnie zgłasza dwa wyjątki.It then throws two exceptions. Pierwszy jest obsługiwany przez blok try/catch .The first is handled by a try/catch block. Druga jest nieobsługiwana i wywołuje MyHandle procedurę przed zakończeniem działania aplikacji.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()

Uwagi

To zdarzenie zapewnia powiadomienie o nieprzechwyconych wyjątkach.This event provides notification of uncaught exceptions. Dzięki temu aplikacja może rejestrować informacje o wyjątku przed użyciem domyślnej procedury obsługi przez system, a następnie kończy działanie aplikacji.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. Jeśli jest dostępna wystarczająca ilość informacji o stanie aplikacji, można podjąć inne działania — takie jak zapisywanie danych programu do późniejszego odzyskiwania.If sufficient information about the state of the application is available, other actions may be undertaken - such as saving program data for later recovery. Należy zachować ostrożność, ponieważ dane programu mogą ulec uszkodzeniu, gdy wyjątki nie są obsługiwane.Caution is advised, because program data can become corrupted when exceptions are not handled.

Uwaga

W .NET Framework wersje 1,0 i 1,1 Opcje zakończenia i debugowania aplikacji są raportowane użytkownikowi przed podjęciem tego zdarzenia, a nie po.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.

To zdarzenie może być obsługiwane w dowolnej domenie aplikacji.This event can be handled in any application domain. Jednak zdarzenie nie jest zawsze zgłaszane w domenie aplikacji, w której wystąpił wyjątek.However, the event is not necessarily raised in the application domain where the exception occurred. Wyjątek jest nieobsługiwany tylko wtedy, gdy cały stos wątku został odłączony bez znajdowania odpowiedniego programu obsługi wyjątków, więc pierwsze miejsce, w którym zdarzenie może zostać wywołane, znajduje się w domenie aplikacji, z której pochodzi wątek.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.

Uwaga

W .NET Framework wersje 1,0 i 1,1 to zdarzenie występuje tylko w przypadku domyślnej domeny aplikacji utworzonej przez system podczas uruchamiania aplikacji.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. Jeśli aplikacja tworzy dodatkowe domeny aplikacji, określenie delegata tego zdarzenia w tych domenach nie ma żadnego wpływu.If an application creates additional application domains, specifying a delegate for this event in those applications domains has no effect.

Jeśli UnhandledException zdarzenie jest obsługiwane w domyślnej domenie aplikacji, zostanie zgłoszone dla dowolnego nieobsłużonego wyjątku w dowolnym wątku, niezależnie od tego, jaką domenę aplikacji uruchomił wątek.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. Jeśli wątek uruchomiony w domenie aplikacji, która ma program obsługi zdarzeń dla UnhandledException , zdarzenie jest zgłaszane w domenie aplikacji.If the thread started in an application domain that has an event handler for UnhandledException, the event is raised in that application domain. Jeśli ta domena aplikacji nie jest domyślną domeną aplikacji i istnieje również procedura obsługi zdarzeń w domenie domyślnej aplikacji, zdarzenie jest zgłaszane w obu domenach aplikacji.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.

Załóżmy na przykład, że wątek zaczyna się w domenie aplikacji "AD1", wywołuje metodę w domenie aplikacji "AD2", a następnie wywołuje metodę w domenie aplikacji "AD3", w której zgłasza wyjątek.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. Pierwszą domeną aplikacji, w której UnhandledException może zostać zgłoszone zdarzenie, jest "AD1".The first application domain in which the UnhandledException event can be raised is "AD1". Jeśli ta domena aplikacji nie jest domyślną domeną aplikacji, zdarzenie może być również zgłaszane w domyślnej domenie aplikacji.If that application domain is not the default application domain, the event can also be raised in the default application domain.

Uwaga

Czas wykonywania wątku w środowisku uruchomieniowym języka wspólnego zostanie przerwany, gdy programy obsługi zdarzeń dla UnhandledException zdarzenia są wykonywane.The common language runtime suspends thread aborts while event handlers for the UnhandledException event are executing.

Jeśli program obsługi zdarzeń ma ReliabilityContractAttribute atrybut z odpowiednimi flagami, program obsługi zdarzeń jest traktowany jako ograniczony region wykonania.If the event handler has a ReliabilityContractAttribute attribute with the appropriate flags, the event handler is treated as a constrained execution region.

Począwszy od .NET Framework 4, to zdarzenie nie jest wywoływane w przypadku wyjątków, które uszkadzają stan procesu, takich jak przepełnienia stosu lub naruszeń dostępu, chyba że program obsługi zdarzeń ma krytyczne znaczenie dla zabezpieczeń i ma HandleProcessCorruptedStateExceptionsAttribute atrybut.Starting with the .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.

W .NET Framework wersje 1,0 i 1,1, nieobsłużony wyjątek występujący w wątku innym niż główny wątek aplikacji jest przechwytywany przez środowisko uruchomieniowe i w związku z tym nie powoduje przerwania działania aplikacji.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. W ten sposób można zgłaszać UnhandledException zdarzenie bez przerywania działania aplikacji.Thus, it is possible for the UnhandledException event to be raised without the application terminating. Począwszy od .NET Framework w wersji 2,0, to Nieobsłużone wyjątki w wątkach podrzędnych zostały usunięte, ponieważ skumulowany efekt takich niepowodzeń nie obejmuje obniżenia wydajności, uszkodzenia danych i zawieszania, z których wszystkie były trudne do debugowania.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. Aby uzyskać więcej informacji, w tym listę przypadków, w których środowisko uruchomieniowe nie zostało zakończone, zobacz wyjątki w zarządzanych wątkach.For more information, including a list of cases in which the runtime does not terminate, see Exceptions in Managed Threads.

Aby zarejestrować procedurę obsługi zdarzeń dla tego zdarzenia, musisz mieć wymagane uprawnienia lub SecurityException zgłaszać.To register an event handler for this event, you must have the required permissions, or a SecurityException is thrown.

Aby uzyskać więcej informacji na temat obsługi zdarzeń, zobacz Obsługa iwywoływanie zdarzeń.For more information about handling events, see Handling and Raising Events.

Inne zdarzenia dla nieobsłużonych wyjątkówOther Events for Unhandled Exceptions

W przypadku niektórych modeli aplikacji UnhandledException zdarzenie może być przechodzące przez inne zdarzenia, jeśli wystąpił nieobsługiwany wyjątek w wątku aplikacji głównej.For certain application models, the UnhandledException event can be preempted by other events if the unhandled exception occurs in the main application thread.

W aplikacjach, które używają Windows Forms, Nieobsłużone wyjątki w wątku aplikacji głównej powodują wystąpienie Application.ThreadException zdarzenia.In applications that use Windows Forms, unhandled exceptions in the main application thread cause the Application.ThreadException event to be raised. Jeśli to zdarzenie jest obsługiwane, zachowanie domyślne polega na tym, że nieobsługiwany wyjątek nie kończy działanie aplikacji, chociaż aplikacja pozostaje w nieznanym stanie.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. W takim przypadku UnhandledException zdarzenie nie zostanie zgłoszone.In that case, the UnhandledException event is not raised. To zachowanie można zmienić przy użyciu pliku konfiguracyjnego aplikacji lub przy użyciu Application.SetUnhandledExceptionMode metody zmiany trybu na przed podłączaniem UnhandledExceptionMode.ThrowException ThreadException programu obsługi zdarzeń.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. Dotyczy to tylko głównego wątku aplikacji.This applies only to the main application thread. UnhandledExceptionZdarzenie jest zgłaszane w przypadku nieobsłużonych wyjątków zgłoszonych w innych wątkach.The UnhandledException event is raised for unhandled exceptions thrown in other threads.

Począwszy od Microsoft Visual Studio 2005, Visual Basic Framework aplikacji zapewnia inne zdarzenie dla nieobsłużonych wyjątków w wątku aplikacji głównej.Starting with Microsoft Visual Studio 2005, the Visual Basic application framework provides another event for unhandled exceptions in the main application thread. Zobacz WindowsFormsApplicationBase.UnhandledException zdarzenie.See the WindowsFormsApplicationBase.UnhandledException event. To zdarzenie ma obiekt argumentów zdarzeń o takiej samej nazwie, jak obiekt argumentów zdarzeń używany przez AppDomain.UnhandledException , ale z innymi właściwościami.This event has an event arguments object with the same name as the event arguments object used by AppDomain.UnhandledException, but with different properties. W szczególności ten obiekt argumentów zdarzeń ma ExitApplication Właściwość, która umożliwia kontynuowanie działania aplikacji, ignorując nieobsłużony wyjątek (i pozostawiając aplikację w nieznanym stanie).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). W takim przypadku AppDomain.UnhandledException zdarzenie nie zostanie zgłoszone.In that case, the AppDomain.UnhandledException event is not raised.

Dotyczy