ThreadAbortException Clase

Definición

public ref class ThreadAbortException sealed : SystemException

public sealed class ThreadAbortException : SystemException

[System.Serializable]
public sealed class ThreadAbortException : SystemException

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class ThreadAbortException : SystemException

type ThreadAbortException = class
    inherit SystemException

[<System.Serializable>]
type ThreadAbortException = class
    inherit SystemException

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ThreadAbortException = class
    inherit SystemException

Public NotInheritable Class ThreadAbortException
Inherits SystemException

Herencia

Object

Exception

SystemException

ThreadAbortException

Atributos

SerializableAttribute ComVisibleAttribute

Ejemplos

En el ejemplo siguiente se muestra cómo anular un subproceso. El subproceso que recibe ThreadAbortException usa el método para cancelar la solicitud de ResetAbort anulación y continuar ejecutándose.

using namespace System;
using namespace System::Threading;
using namespace System::Security::Permissions;
ref class ThreadWork
{
public:
   static void DoWork()
   {
      try
      {
         for ( int i = 0; i < 100; i++ )
         {
            Console::WriteLine( "Thread - working." );
            Thread::Sleep( 100 );

         }
      }
      catch ( ThreadAbortException^ e ) 
      {
         Console::WriteLine( "Thread - caught ThreadAbortException - resetting." );
         Console::WriteLine( "Exception message: {0}", e->Message );
         Thread::ResetAbort();
      }

      Console::WriteLine( "Thread - still alive and working." );
      Thread::Sleep( 1000 );
      Console::WriteLine( "Thread - finished working." );
   }

};

int main()
{
   ThreadStart^ myThreadDelegate = gcnew ThreadStart( ThreadWork::DoWork );
   Thread^ myThread = gcnew Thread( myThreadDelegate );
   myThread->Start();
   Thread::Sleep( 100 );
   Console::WriteLine( "Main - aborting my thread." );
   myThread->Abort();
   myThread->Join();
   Console::WriteLine( "Main ending." );
}

using System;
using System.Threading;
using System.Security.Permissions;

public class ThreadWork {
    public static void DoWork() {
        try {
            for(int i=0; i<100; i++) {
                Console.WriteLine("Thread - working.");
                Thread.Sleep(100);
            }
        }
        catch(ThreadAbortException e) {
            Console.WriteLine("Thread - caught ThreadAbortException - resetting.");
            Console.WriteLine("Exception message: {0}", e.Message);
            Thread.ResetAbort();
        }
        Console.WriteLine("Thread - still alive and working.");
        Thread.Sleep(1000);
        Console.WriteLine("Thread - finished working.");
    }
}

class ThreadAbortTest {
    public static void Main() {
        ThreadStart myThreadDelegate = new ThreadStart(ThreadWork.DoWork);
        Thread myThread = new Thread(myThreadDelegate);
        myThread.Start();
        Thread.Sleep(100);
        Console.WriteLine("Main - aborting my thread.");
        myThread.Abort();
        myThread.Join();
        Console.WriteLine("Main ending.");
    }
}

Imports System.Threading
Imports System.Security.Permissions


Public Class ThreadWork
   Public Shared Sub DoWork()
      Try
         Dim i As Integer
         For i = 0 To 99
            Console.WriteLine("Thread - working.")
            Thread.Sleep(100)
         Next i
      Catch e As ThreadAbortException
         Console.WriteLine("Thread - caught ThreadAbortException - resetting.")
         Console.WriteLine("Exception message: {0}", e.Message)
         Thread.ResetAbort()
      End Try
      Console.WriteLine("Thread - still alive and working.")
      Thread.Sleep(1000)
      Console.WriteLine("Thread - finished working.")
   End Sub
End Class


Class ThreadAbortTest
   Public Shared Sub Main()
      Dim myThreadDelegate As New ThreadStart(AddressOf ThreadWork.DoWork)
      Dim myThread As New Thread(myThreadDelegate)
      myThread.Start()
      Thread.Sleep(100)
      Console.WriteLine("Main - aborting my thread.")
      myThread.Abort()
      myThread.Join()
      Console.WriteLine("Main ending.")
   End Sub
End Class

Este código genera el siguiente resultado:

Thread - working.  
Main - aborting my thread.  
Thread - caught ThreadAbortException - resetting.  
Exception message: Thread was being aborted.  
Thread - still alive and working.  
Thread - finished working.  
Main ending.  

Comentarios

Cuando se realiza una llamada al método Abort para destruir un subproceso, Common Language Runtime produce una ThreadAbortException excepción . ThreadAbortException es una excepción especial que se puede detectar, pero se volverá a generar automáticamente al final del catch bloque. Cuando se produce esta excepción, el tiempo de ejecución ejecuta todos los bloques finally antes de finalizar el subproceso. Dado que el subproceso puede realizar un cálculo sin enlazar en los bloques o llamar a para cancelar la anulación, no hay ninguna garantía de que el subproceso terminará finally Thread.ResetAbort alguna vez. Si desea esperar hasta que el subproceso anulado haya finalizado, puede llamar al Thread.Join método . Join es una llamada de bloqueo que no se devuelve hasta que el subproceso deja de ejecutarse realmente.

Solo .NET Core: Aunque este tipo existe en .NET Core, puesto que no se Abort admite, Common Language Runtime nunca inicia ThreadAbortException .

ThreadAbortException usa el valor HRESULT COR_E_THREADABORTED, que tiene el valor 0x80131530.

Propiedades

Métodos

Eventos

Se aplica a

Consulte también

• Thread
• Abort(Object)
• Destrucción de subprocesos