Well, it is, now, technically possible to use Thread.Abort on .NET!
Download this NuGet package: <https://www.nuget.org/packages/NET-Thread.Terminate> -
add it to your project.
However, this is not a recommended approach on .NET anymore. Your code shouldn't ever reach the point where you lose the control of your thread in an ideal production scenario: to end a thread in production code, prefer cooperative cancellation such as [CancellationToken](https://learn.microsoft.com/en-us/dotnet/api/system.threading.cancellationtoken).
You can abort the thread by calling the extension method DotNetAbort:
```csharp SomeThread.DotNetAbort(); // The DotNetAbort method may corrupt the process and should not be used in production code. ```
This is the same as the removed Thread.Abort method; however, There is a catch you when aborting the thread on .NET 5 and .NET 6 using this method: a random exception might be thrown at the thread before the main ThreadAbortException exception; this possible case must be handled like the code below:
```csharp   Thread SomeThread = new Thread(() => { Exception exception = null; try { try { for (; ; Thread.Sleep(150)) { Console.WriteLine("Stop me!"); } } catch (Exception ex) { exception = ex; } } catch (ThreadAbortException ex) { exception = ex; // Use ResetAbort() to reset the abortion when using DotNetAbort methods; not Thread.ResetAbort()! Thread.CurrentThread.ResetAbort(); } if (exception != null) { // doing finalizing stuff
if (exception.GetType() == typeof(ThreadAbortException)) { return; } Console.WriteLine($"An error occurred. {exception.Message}"); } }) { Name = ".NET Thread", IsBackground = true };
SomeThread.Start(); SomeThread.DotNetAbort(); ```
This only needs to be done on .NET 5 and .NET 6; starting with .NET 7, this isn't necessary, so just handle it the way you would before.
To reset the abort request, use the extension method ResetAbort instead:
```csharp SomeThread.ResetAbort(); ```
You could also terminate the .NET on an OS level the way you do a native thread by calling the extension method Terminate:
```csharp SomeThread.Terminate(); // Calling this method might cause corruption in the runtime; avoid practicing usage in an ideal production scenario ```

Well, it is, now, technically possible to use Thread.Abort on .NET.
Download this NuGet package: <https://www.nuget.org/packages/NET-Thread.Terminate> -
add it to your project.
However, this is not a recommended approach on .NET anymore. Your code shouldn't ever reach the point where you lose the control of your thread in an ideal production scenario: to end a thread in production code, prefer cooperative cancellation such as [CancellationToken](https://learn.microsoft.com/en-us/dotnet/api/system.threading.cancellationtoken).
You can abort the thread by calling the extension method DotNetAbort:
```csharp SomeThread.DotNetAbort(); // The DotNetAbort method may corrupt the process and should not be used in production code. ```
This is the same as the removed Thread.Abort method; however, There is a catch you when aborting the thread on .NET 5 and .NET 6 using this method: a random exception might be thrown at the thread before the main ThreadAbortException exception; this possible case must be handled like the code below:
```csharp   Thread SomeThread = new Thread(() => { Exception exception = null; try { try { for (; ; Thread.Sleep(150)) { Console.WriteLine("Stop me!"); } } catch (Exception ex) { exception = ex; } } catch (ThreadAbortException ex) { exception = ex; // Use ResetAbort() to reset the abortion when using DotNetAbort methods; not Thread.ResetAbort()! Thread.CurrentThread.ResetAbort(); } if (exception != null) { // doing finalizing stuff
if (exception.GetType() == typeof(ThreadAbortException)) { return; } Console.WriteLine($"An error occurred. {exception.Message}"); } }) { Name = ".NET Thread", IsBackground = true };
SomeThread.Start(); SomeThread.DotNetAbort(); ```
This only needs to be done on .NET 5 and .NET 6; starting with .NET 7, this isn't necessary, so just handle it the way you would before.
To reset the abort request, use the extension method ResetAbort instead:
```csharp SomeThread.ResetAbort(); ```
You could also terminate the .NET on an OS level the way you do a native thread by calling the extension method Terminate:
```csharp SomeThread.Terminate(); // Calling this method might cause corruption in the runtime; avoid practicing usage in an ideal production scenario ```
One example relevant to your case:
[A thread stuck at a native call](https://i.sstatic.net/zznM285n.png)
It's a thread attempting to read a 1 GB file in two minutes using the Windows API Function ReadFile. We intend to end that thread after those 2 minutes are passed; however, this is not possible by default on .NET even using .NET Framework Thread.Abort since you can't abort a thread in the preemptive mode so we're left with only bad solutions here: one of them is using the vicious style of thread termination using the above Terminate method. Ideally, you should avoid using that in production since it might cause corruption in the runtime, resources unreleased or locks still held.