In this chapter, we will cover the basic tasks to work with threads in C#. You will learn the following recipes:
Creating a thread in C#
Pausing a thread
Making a thread wait
Aborting a thread
Determining a thread state
Thread priority
Foreground and background threads
Passing parameters to a thread
Locking with a C# lock keyword
Locking with a
MonitorconstructHandling exceptions
At some point of time in the past, the common computer had only one computing unit and could not execute several computing tasks simultaneously. However, operating systems could already work with multiple programs simultaneously, implementing the concept of multitasking. To prevent the possibility of one program taking control of the CPU forever, causing other applications and the operating system itself to hang, the operating systems had to split a physical computing unit across a few virtualized processors in some way and give a certain amount of computing power to each executing program. Moreover, an operating system must always have priority access to the CPU and should be able to prioritize CPU access to different programs. A thread is an implementation of this concept. It could be considered as a virtual processor that is given to the one specific program and runs it independently.
Note
Remember that a thread consumes a significant amount of operating system resources. Trying to share one physical processor across many threads will lead to a situation where an operating system is busy just managing threads instead of running programs.
Therefore, while it was possible to enhance computer processors, making them execute more and more commands per second, working with threads was usually an operating system task. There was no sense in trying to compute some tasks in parallel on a single-core CPU because it would take more time than running those computations sequentially. However, when processors started to have more computing cores, older programs could not take advantage of this because they just used one processor core.
To use a modern processor's computing power effectively, it is very important to be able to compose a program in a way that it can use more than one computing core, which leads to organizing it as several threads that communicate and synchronize with each other.
The recipes in this chapter focus on performing some very basic operations with threads in the C# language. We will cover a thread's life cycle, which includes creating, suspending, making a thread wait, and aborting a thread, and then, we will go through the basic synchronization techniques.
Throughout the following recipes, we will use Visual Studio 2015 as the main tool to write multithreaded programs in C#. This recipe will show you how to create a new C# program and use threads in it.
Note
A free Visual Studio Community 2015 IDE can be downloaded from the Microsoft website and used to run the code samples.
To work through this recipe, you will need Visual Studio 2015. There are no other prerequisites. The source code for this recipe can be found in the BookSamples\Chapter1\Recipe1 directory.
Tip
Downloading the example code
You can download the example code files for this book from your account at http://www.packtpub.com. If you purchased this book elsewhere, you can visit http://www.packtpub.com/support and register to have the files e-mailed directly to you.
You can download the code files by following these steps:
Log in or register to our website using your e-mail address and password.
Hover the mouse pointer on the SUPPORT tab at the top.
Click on Code Downloads & Errata.
Enter the name of the book in the Search box.
Select the book for which you're looking to download the code files.
Choose from the drop-down menu where you purchased this book from.
Click on Code Download.
Once the file is downloaded, please make sure that you unzip or extract the folder using the latest version of:
WinRAR/7-Zip for Windows
Zipeg/iZip / UnRarX for Mac
7-Zip/PeaZip for Linux
To understand how to create a new C# program and use threads in it, perform the following steps:
Start Visual Studio 2015. Create a new C# console application project.
Make sure that the project uses .NET Framework 4.6 or higher; however, the code in this chapter will work with previous versions.
In the
Program.csfile, add the followingusingdirectives:using System; using System.Threading; using static System.Console;
Add the following code snippet below the
Mainmethod:static void PrintNumbers() { WriteLine("Starting..."); for (int i = 1; i < 10; i++) { WriteLine(i); } }Add the following code snippet inside the
Mainmethod:Thread t = new Thread(PrintNumbers); t.Start(); PrintNumbers();
Run the program. The output will be something like the following screenshot:
In step 1 and 2, we created a simple console application in C# using .Net Framework version 4.0. Then, in step 3, we included the System.Threading namespace, which contains all the types needed for the program. Then, we used the using static feature from C# 6.0, which allows us to use the System.Console type's static methods without specifying the type name.
Note
An instance of a program that is being executed can be referred to as a process. A process consists of one or more threads. This means that when we run a program, we always have one main thread that executes the program code.
In step 4, we defined the PrintNumbers method, which will be used in both the main and newly created threads. Then, in step 5, we created a thread that runs
PrintNumbers. When we construct a thread, an instance of the ThreadStart or ParameterizedThreadStart delegate is passed to the constructor. The C# compiler creates this object behind the scenes when we just type the name of the method we want to run in a different thread. Then, we start a thread and run PrintNumbers in the usual manner on the main thread.
As a result, there will be two ranges of numbers from 1 to 10 randomly crossing each other. This illustrates that the PrintNumbers method runs simultaneously on the main thread and on the other thread.
This recipe will show you how to make a thread wait for some time without wasting operating system resources.
To work through this recipe, you will need Visual Studio 2015. There are no other prerequisites. The source code for this recipe can be found at BookSamples\Chapter1\Recipe2.
To understand how to make a thread wait without wasting operating system resources, perform the following steps:
Start Visual Studio 2015. Create a new C# console application project.
In the
Program.csfile, add the followingusingdirectives:using System; using System.Threading; using static System.Console; using static System.Threading.Thread;
Add the following code snippet below the
Mainmethod:static void PrintNumbers() { WriteLine("Starting..."); for (int i = 1; i < 10; i++) { WriteLine(i); } } static void PrintNumbersWithDelay() { WriteLine("Starting..."); for (int i = 1; i < 10; i++) { Sleep(TimeSpan.FromSeconds(2)); WriteLine(i); } }Add the following code snippet inside the
Mainmethod:Thread t = new Thread(PrintNumbersWithDelay); t.Start(); PrintNumbers();
Run the program.
When the program is run, it creates a thread that will execute a code in the PrintNumbersWithDelay method. Immediately after that, it runs the PrintNumbers method. The key feature here is adding the Thread.Sleep method call to a PrintNumbersWithDelay method. It causes the thread executing this code to wait a specified amount of time (2 seconds in our case) before printing each number. While a thread sleeps, it uses as little CPU time as possible. As a result, we will see that the code in the PrintNumbers method, which usually runs later, will be executed before the code in the PrintNumbersWithDelay method in a separate thread.
This recipe will show you how a program can wait for some computation in another thread to complete to use its result later in the code. It is not enough to use the Thread.Sleep method because we don't know the exact time the computation will take.
To work through this recipe, you will need Visual Studio 2015. There are no other prerequisites. The source code for this recipe can be found at BookSamples\Chapter1\Recipe3.
To understand how a program waits for some computation in another thread to complete in order to use its result later, perform the following steps:
Start Visual Studio 2015. Create a new C# console application project.
In the
Program.csfile, add the followingusingdirectives:using System; using System.Threading; using static System.Console; using static System.Threading.Thread;
Add the following code snippet below the
Mainmethod:static void PrintNumbersWithDelay() { WriteLine("Starting..."); for (int i = 1; i < 10; i++) { Sleep(TimeSpan.FromSeconds(2)); WriteLine(i); } }Add the following code snippet inside the
Mainmethod:WriteLine("Starting..."); Thread t = new Thread(PrintNumbersWithDelay); t.Start(); t.Join(); WriteLine("Thread completed");Run the program.
When the program is run, it runs a long-running thread that prints out numbers and waits two seconds before printing each number. But, in the main program, we called the t.Join method, which allows us to wait for the thread t to complete working. When it is complete, the main program continues to run. With the help of this technique, it is possible to synchronize execution steps between two threads. The first one waits until another one is complete and then continues to work. While the first thread waits, it is in a blocked state (as it is in the previous recipe when you call Thread.Sleep).
In this recipe, we will describe how to abort another thread's execution.
To work through this recipe, you will need Visual Studio 2015. There are no other prerequisites. The source code for this recipe can be found at BookSamples\Chapter1\Recipe4.
To understand how to abort another thread's execution, perform the following steps:
Start Visual Studio 2015. Create a new C# console application project.
In the
Program.csfile, add the followingusingdirectives:using System; using System.Threading; using static System.Console;
Using the static
System.Threading.Thread, add the following code snippet below theMainmethod:static void PrintNumbersWithDelay() { WriteLine("Starting..."); for (int i = 1; i < 10; i++) { Sleep(TimeSpan.FromSeconds(2)); WriteLine(i); } }Add the following code snippet inside the
Mainmethod:WriteLine("Starting program..."); Thread t = new Thread(PrintNumbersWithDelay); t.Start(); Thread.Sleep(TimeSpan.FromSeconds(6)); t.Abort(); WriteLine("A thread has been aborted"); Thread t = new Thread(PrintNumbers); t.Start(); PrintNumbers();Run the program.
When the main program and a separate number-printing thread run, we wait for six seconds and then call a t.Abort method on a thread. This injects a ThreadAbortException method into a thread, causing it to terminate. It is very dangerous, generally because this exception can happen at any point and may totally destroy the application. In addition, it is not always possible to terminate a thread with this technique. The target thread may refuse to abort by handling this exception by calling the Thread.ResetAbort method. Thus, it is not recommended that you use the Abort method to close a thread. There are different methods that are preferred, such as providing a CancellationToken object to cancel a thread execution. This approach will be described in Chapter 3, Using a Thread Pool.
This recipe will describe the possible states a thread could have. It is useful to get information about whether a thread is started yet or whether it is in a blocked state. Note that because a thread runs independently, its state could be changed at any time.
To work through this recipe, you will need Visual Studio 2015. There are no other prerequisites. The source code for this recipe can be found at BookSamples\Chapter1\Recipe5.
To understand how to determine a thread state and acquire useful information about it, perform the following steps:
Start Visual Studio 2015. Create a new C# console application project.
In the
Program.csfile, add the followingusingdirectives:using System; using System.Threading; using static System.Console; using static System.Threading.Thread;
Add the following code snippet below the
Mainmethod:static void DoNothing() { Sleep(TimeSpan.FromSeconds(2)); } static void PrintNumbersWithStatus() { WriteLine("Starting..."); WriteLine(CurrentThread.ThreadState.ToString()); for (int i = 1; i < 10; i++) { Sleep(TimeSpan.FromSeconds(2)); WriteLine(i); } }Add the following code snippet inside the
Mainmethod:WriteLine("Starting program..."); Thread t = new Thread(PrintNumbersWithStatus); Thread t2 = new Thread(DoNothing); WriteLine(t.ThreadState.ToString()); t2.Start(); t.Start(); for (int i = 1; i < 30; i++) { WriteLine(t.ThreadState.ToString()); } Sleep(TimeSpan.FromSeconds(6)); t.Abort(); WriteLine("A thread has been aborted"); WriteLine(t.ThreadState.ToString()); WriteLine(t2.ThreadState.ToString());Run the program.
When the main program starts, it defines two different threads; one of them will be aborted and the other runs successfully. The thread state is located in the ThreadState property of a Thread object, which is a C# enumeration. At first, the thread has a ThreadState.Unstarted state. Then, we run it and assume that for the duration of 30 iterations of a cycle, the thread will change its state from ThreadState.Running to ThreadState.WaitSleepJoin.
Tip
Note that the current Thread object is always accessible through the Thread.CurrentThread static property.
If this does not happen, just increase the number of iterations. Then, we abort the first thread and see that now it has a ThreadState.Aborted state. It is also possible that the program will print out the ThreadState.AbortRequested state. This illustrates, very well, the complexity of synchronizing two threads. Keep in mind that you should not use thread abortion in your programs. I've covered it here only to show the corresponding thread state.
Finally, we can see that our second thread t2 was completed successfully and now has a ThreadState.Stopped state. There are several other states, but they are partly deprecated and not as useful as those we examined.
This recipe will describe the different options for thread priority. Setting a thread priority determines how much CPU time a thread will be given.
To work through this recipe, you will need Visual Studio 2015. There are no other prerequisites. The source code for this recipe can be found at BookSamples\Chapter1\Recipe6.
To understand the workings of thread priority, perform the following steps:
Start Visual Studio 2015. Create a new C# console application project.
In the
Program.csfile, add the followingusingdirectives:using System; using System.Threading; using static System.Console; using static System.Threading.Thread; using static System.Diagnostics.Process;
Add the following code snippet below the
Mainmethod:static void RunThreads() { var sample = new ThreadSample(); var threadOne = new Thread(sample.CountNumbers); threadOne.Name = "ThreadOne"; var threadTwo = new Thread(sample.CountNumbers); threadTwo.Name = "ThreadTwo"; threadOne.Priority = ThreadPriority.Highest; threadTwo.Priority = ThreadPriority.Lowest; threadOne.Start(); threadTwo.Start(); Sleep(TimeSpan.FromSeconds(2)); sample.Stop(); } class ThreadSample { private bool _isStopped = false; public void Stop() { _isStopped = true; } public void CountNumbers() { long counter = 0; while (!_isStopped) { counter++; } WriteLine($"{CurrentThread.Name} with " + $"{CurrentThread.Priority,11} priority " + $"has a count = {counter,13:N0}"); } }Add the following code snippet inside the
Mainmethod:WriteLine($"Current thread priority: {CurrentThread.Priority}"); WriteLine("Running on all cores available"); RunThreads(); Sleep(TimeSpan.FromSeconds(2)); WriteLine("Running on a single core"); GetCurrentProcess().ProcessorAffinity = new IntPtr(1); RunThreads();Run the program.
When the main program starts, it defines two different threads. The first one, threadOne, has the highest thread priority ThreadPriority.Highest, while the second one, that is threadTwo, has the lowest ThreadPriority.Lowest priority. We print out the main thread priority value and then start these two threads on all available cores. If we have more than one computing core, we should get an initial result within two seconds. The highest priority thread should calculate more iterations usually, but both values should be close. However, if there are any other programs running that load all the CPU cores, the situation could be quite different.
To simulate this situation, we set up the ProcessorAffinity option, instructing the operating system to run all our threads on a single CPU core (number 1). Now, the results should be very different, and the calculations will take more than two seconds. This happens because the CPU core runs mostly the high-priority thread, giving the rest of the threads very little time.
Note that this is an illustration of how an operating system works with thread prioritization. Usually, you should not write programs relying on this behavior.
This recipe will describe what foreground and background threads are and how setting this option affects the program's behavior.
To work through this recipe, you will need Visual Studio 2015. There are no other prerequisites. The source code for this recipe can be found at BookSamples\Chapter1\Recipe7.
To understand the effect of foreground and background threads on a program, perform the following steps:
Start Visual Studio 2015. Create a new C# console application project.
In the
Program.csfile, add the followingusingdirectives:using System; using System.Threading; using static System.Console; using static System.Threading.Thread;
Add the following code snippet below the
Mainmethod:class ThreadSample { private readonly int _iterations; public ThreadSample(int iterations) { _iterations = iterations; } public void CountNumbers() { for (int i = 0; i < _iterations; i++) { Sleep(TimeSpan.FromSeconds(0.5)); WriteLine($"{CurrentThread.Name} prints {i}"); } } }Add the following code snippet inside the
Mainmethod:var sampleForeground = new ThreadSample(10); var sampleBackground = new ThreadSample(20); var threadOne = new Thread(sampleForeground.CountNumbers); threadOne.Name = "ForegroundThread"; var threadTwo = new Thread(sampleBackground.CountNumbers); threadTwo.Name = "BackgroundThread"; threadTwo.IsBackground = true; threadOne.Start(); threadTwo.Start();
Run the program.
When the main program starts, it defines two different threads. By default, a thread that we create explicitly is a foreground thread. To create a background thread, we manually set the IsBackground property of the threadTwo object to true. We configure these threads in a way that the first one will be completed faster, and then we run the program.
After the first thread is complete, the program shuts down and the background thread is terminated. This is the main difference between the two: a process waits for all the foreground threads to complete before finishing the work, but if it has background threads, they just shut down.
It is also important to mention that if a program defines a foreground thread that does not get completed; the main program does not end properly.
This recipe will describe how to provide code that we run in another thread with the required data. We will go through the different ways to fulfill this task and review common mistakes.
To work through this recipe, you will need Visual Studio 2015. There are no other prerequisites. The source code for this recipe can be found at BookSamples\Chapter1\Recipe8.
To understand how to pass parameters to a thread, perform the following steps:
Start Visual Studio 2015. Create a new C# console application project.
In the
Program.csfile, add the followingusingdirectives:using System; using System.Threading; using static System.Console; using static System.Threading.Thread;
Add the following code snippet below the
Mainmethod:static void Count(object iterations) { CountNumbers((int)iterations); } static void CountNumbers(int iterations) { for (int i = 1; i <= iterations; i++) { Sleep(TimeSpan.FromSeconds(0.5)); WriteLine($"{CurrentThread.Name} prints {i}"); } } static void PrintNumber(int number) { WriteLine(number); } class ThreadSample { private readonly int _iterations; public ThreadSample(int iterations) { _iterations = iterations; } public void CountNumbers() { for (int i = 1; i <= _iterations; i++) { Sleep(TimeSpan.FromSeconds(0.5)); WriteLine($"{CurrentThread.Name} prints {i}"); } } }Add the following code snippet inside the
Mainmethod:var sample = new ThreadSample(10); var threadOne = new Thread(sample.CountNumbers); threadOne.Name = "ThreadOne"; threadOne.Start(); threadOne.Join(); WriteLine("--------------------------"); var threadTwo = new Thread(Count); threadTwo.Name = "ThreadTwo"; threadTwo.Start(8); threadTwo.Join(); WriteLine("--------------------------"); var threadThree = new Thread(() => CountNumbers(12)); threadThree.Name = "ThreadThree"; threadThree.Start(); threadThree.Join(); WriteLine("--------------------------"); int i = 10; var threadFour = new Thread(() => PrintNumber(i)); i = 20; var threadFive = new Thread(() => PrintNumber(i)); threadFour.Start(); threadFive.Start();Run the program.
When the main program starts, it first creates an object of the ThreadSample class, providing it with a number of iterations. Then, we start a thread with the object's CountNumbers method. This method runs in another thread, but it uses the number 10, which is the value that we passed to the object's constructor. Therefore, we just passed this number of iterations to another thread in the same indirect way.
Another way to pass data is to use the Thread.Start method by accepting an object that can be passed to another thread. To work this way, a method that we started in another thread must accept one single parameter of the type object. This option is illustrated by creating a threadTwo thread. We pass 8 as an object to the Count method, where it is cast to an integer type.
The next option involves the use of lambda expressions. A lambda expression defines a method that does not belong to any class. We create such a method that invokes another method with the arguments needed and start it in another thread. When we start the threadThree thread, it prints out 12 numbers, which are exactly the numbers we passed to it via the lambda expression.
The use of lambda expressions involves another C# construct named closure. When we use any local variable in a lambda expression, C# generates a class and makes this variable a property of this class. So, actually, we do the same thing as in the threadOne thread, but we do not define the class ourselves; the C# compiler does this automatically.
This could lead to several problems; for example, if we use the same variable from several lambdas, they will actually share this variable value. This is illustrated by the previous example where, when we start threadFour and threadFive, they both print 20 because the variable was changed to hold the value 20 before both threads were started.
This recipe will describe how to ensure that when one thread uses some resource, another does not simultaneously use it. We will see why this is needed and what the thread safety concept is all about.
To work through this recipe, you will need Visual Studio 2015. There are no other prerequisites. The source code for this recipe can be found at BookSamples\Chapter1\Recipe9.
To understand how to use the C# lock keyword, perform the following steps:
Start Visual Studio 2015. Create a new C# console application project.
In the
Program.csfile, add the followingusingdirectives:using System; using System.Threading; using static System.Console;
Add the following code snippet below the
Mainmethod:static void TestCounter(CounterBase c) { for (int i = 0; i < 100000; i++) { c.Increment(); c.Decrement(); } } class Counter : CounterBase { public int Count { get; private set; } public override void Increment() { Count++; } public override void Decrement() { Count--; } } class CounterWithLock : CounterBase { private readonly object _syncRoot = new Object(); public int Count { get; private set; } public override void Increment() { lock (_syncRoot) { Count++; } } public override void Decrement() { lock (_syncRoot) { Count--; } } } abstract class CounterBase { public abstract void Increment(); public abstract void Decrement(); }Add the following code snippet inside the
Mainmethod:WriteLine("Incorrect counter"); var c = new Counter(); var t1 = new Thread(() => TestCounter(c)); var t2 = new Thread(() => TestCounter(c)); var t3 = new Thread(() => TestCounter(c)); t1.Start(); t2.Start(); t3.Start(); t1.Join(); t2.Join(); t3.Join(); WriteLine($"Total count: {c.Count}"); WriteLine("--------------------------"); WriteLine("Correct counter"); var c1 = new CounterWithLock(); t1 = new Thread(() => TestCounter(c1)); t2 = new Thread(() => TestCounter(c1)); t3 = new Thread(() => TestCounter(c1)); t1.Start(); t2.Start(); t3.Start(); t1.Join(); t2.Join(); t3.Join(); WriteLine($"Total count: {c1.Count}");Run the program.
When the main program starts, it first creates an object of the Counter class. This class defines a simple counter that can be incremented and decremented. Then, we start three threads that share the same counter instance and perform an increment and decrement in a cycle. This leads to nondeterministic results. If we run the program several times, it will print out several different counter values. It could be 0, but mostly won't be.
This happens because the Counter class is not thread-safe. When several threads access the counter at the same time, the first thread gets the counter value 10 and increments it to 11. Then, a second thread gets the value 11 and increments it to 12. The first thread gets the counter value 12, but before a decrement takes place, a second thread gets the counter value 12 as well. Then, the first thread decrements 12 to 11 and saves it into the counter, and the second thread simultaneously does the same. As a result, we have two increments and only one decrement, which is obviously not right. This kind of a situation is called a race condition and is a very common cause of errors in a multithreaded environment.
To make sure that this does not happen, we must ensure that while one thread works with the counter, all other threads wait until the first one finishes the work. We can use the lock keyword to achieve this kind of behavior. If we lock an object, all the other threads that require an access to this object will wait in a blocked state until it is unlocked. This could be a serious performance issue and later, in Chapter 2, Thread Synchronization, you will learn more about this.
This recipe illustrates another common multithreaded error called a deadlock. Since a deadlock will cause a program to stop working, the first piece in this example is a new Monitor construct that allows us to avoid a deadlock. Then, the previously described lock keyword is used to get a deadlock.
To work through this recipe, you will need Visual Studio 2015. There are no other prerequisites. The source code for this recipe can be found at BookSamples\Chapter1\Recipe10.
To understand the multithreaded error deadlock, perform the following steps:
Start Visual Studio 2015. Create a new C# console application project.
In the
Program.csfile, add the followingusingdirectives:using System; using System.Threading; using static System.Console; using static System.Threading.Thread;
Add the following code snippet below the
Mainmethod:static void LockTooMuch(object lock1, object lock2) { lock (lock1) { Sleep(1000); lock (lock2); } }Add the following code snippet inside the
Mainmethod:object lock1 = new object(); object lock2 = new object(); new Thread(() => LockTooMuch(lock1, lock2)).Start(); lock (lock2) { Thread.Sleep(1000); WriteLine("Monitor.TryEnter allows not to get stuck, returning false after a specified timeout is elapsed"); if (Monitor.TryEnter(lock1, TimeSpan.FromSeconds(5))) { WriteLine("Acquired a protected resource succesfully"); } else { WriteLine("Timeout acquiring a resource!"); } } new Thread(() => LockTooMuch(lock1, lock2)).Start(); WriteLine("----------------------------------"); lock (lock2) { WriteLine("This will be a deadlock!"); Sleep(1000); lock (lock1) { WriteLine("Acquired a protected resource succesfully"); } }Run the program.
Let's start with the LockTooMuch method. In this method, we just lock the first object, wait for a second, and then lock the second object. Then, we start this method in another thread and try to lock the second object and then the first object from the main thread.
If we use the lock keyword like in the second part of this demo, there will be a deadlock. The first thread holds a lock on the lock1 object and waits while the lock2 object gets free; the main thread holds a lock on the lock2 object and waits for the lock1 object to become free, which will never happen in this situation.
Actually, the lock keyword is syntactic sugar for the Monitor class usage. If we were to disassemble code with lock, we would see that it turns into the following code snippet:
bool acquiredLock = false;
try
{
Monitor.Enter(lockObject, ref acquiredLock);
// Code that accesses resources that are protected by the lock.
}
finally
{
if (acquiredLock)
{
Monitor.Exit(lockObject);
}
}Therefore, we can use the Monitor class directly; it has the TryEnter method, which accepts a timeout parameter and returns false if this timeout parameter expires before we can acquire the resource protected by lock.
This recipe will describe how to handle exceptions in other threads properly. It is very important to always place a try/catch block inside the thread because it is not possible to catch an exception outside a thread's code.
To work through this recipe, you will need Visual Studio 2015. There are no other prerequisites. The source code for this recipe can be found at BookSamples\Chapter1\Recipe11.
To understand the handling of exceptions in other threads, perform the following steps:
Start Visual Studio 2015. Create a new C# console application project.
In the
Program.csfile, add the followingusingdirectives:using System; using System.Threading; using static System.Console; using static System.Threading.Thread;
Add the following code snippet below the
Mainmethod:static void BadFaultyThread() { WriteLine("Starting a faulty thread..."); Sleep(TimeSpan.FromSeconds(2)); throw new Exception("Boom!"); } static void FaultyThread() { try { WriteLine("Starting a faulty thread..."); Sleep(TimeSpan.FromSeconds(1)); throw new Exception("Boom!"); } catch (Exception ex) { WriteLine($"Exception handled: {ex.Message}"); } }Add the following code snippet inside the
Mainmethod:var t = new Thread(FaultyThread); t.Start(); t.Join(); try { t = new Thread(BadFaultyThread); t.Start(); } catch (Exception ex) { WriteLine("We won't get here!"); }Run the program.
When the main program starts, it defines two threads that will throw an exception. One of these threads handles an exception, while the other does not. You can see that the second exception is not caught by a try/catch block around the code that starts the thread. So, if you work with threads directly, the general rule is to not throw an exception from a thread, but to use a try/catch block inside a thread code instead.
In the older versions of .NET Framework (1.0 and 1.1), this behavior was different and uncaught exceptions did not force an application shutdown. It is possible to use this policy by adding an application configuration file (such as app.config) that contains the following code snippet:
<configuration>
<runtime>
<legacyUnhandledExceptionPolicy enabled="1" />
</runtime>
</configuration>
