---
marp: true
paginate: true
math: mathjax
theme: buutti
title: 14. Exceptions, Threads and Tasks
---

# Exceptions, Threads and Tasks

<!-- headingDivider: 5 -->
<!-- class: invert -->

## Exceptions

* Exceptions are problems that occur during the lifetime of the program
* Typical exceptions are `IndexOutOfRangeException` and `NullReferenceException`
  * `IndexOutOfRangeException` occurs when trying to access an element of an object using an index greater than the number of elements in that object
  * `NullReferenceException` occurs when trying to reference a variable that has not been assigned a value

## Checking for exceptions

* There should be some kind of system to check for these problems so that even if they do occur, the application does not crash
  * For example, if a user tries to read from a file that does not exist, the user should be given an informative error message instead of closing the application


<div class='tableborderless'>

| ❌ | ✅ |
| ---------- | --------- |
| ![width:550px](imgs/14%20Exceptions%2C%20Threads%20and%20Tasks_2.png) | ![width:550px](imgs/14%20Exceptions%2C%20Threads%20and%20Tasks_1.png) |    

</div>


## Try-catch

* Wrap the code that could result in an exception in a  *__try__* block

* Wrap the code that should execute if an exception occurs in a  *__catch__* block

  ```csharp
  string path = @"C:\\Users\\Public\\TestFolder\\WriteText.txt";

  try
  {
      string text = System.IO.File.ReadAllText(path);
  }
  catch(DirectoryNotFoundException e)
  {
      Console.WriteLine($"The path {path} does not exist.");
  }
  ```

## Throw

* The *__throw__* keyword results in the exception that is caught in the catch block
* Can be used to execute some code before stopping the execution of the program

  ```csharp
  string path = @"C:\\Users\\Public\\TestFolder\\WriteText.txt";

  try
  {
      string text = System.IO.File.ReadAllText(path);
  }
  catch (IOException e)
  {
      Console.WriteLine("An exception occurred.");
      Console.WriteLine("Logging exception information...");
      Console.WriteLine($"Exception: {e.Message}");
      throw;
  }
  ```

## Finally

* *__finally__* block executes after a try-catch regardless of whether an exception occurred or not
* Useful for closing unmanaged objects like database connections or file streams

  ```csharp
  try
  {
      // Open a database connection or file stream
  }
  catch (SystemException e)
  {
      // Do this if connection / stream fails
  }
  finally
  {
      // Release the unmanaged resources from memory
  }
  ```

## Exercise 1: Debugging Exceptions
<!-- _class: exercise -->

Create a savings calculator which asks the user for a target amount of money the user is aiming for (in integers), and the users monthly salary. For parsing, use the int.Parse() method instead of int.TryParse().

The program then calculates the number of months it will take the user to reach the goal.

After displaying the result, the user is then asked for a path to a  _folder _ where the result is then saved as  _months\_until\_target.txt._

Try your program with different user inputs. Try to intentionally break your program and find as many exceptions as you can.

Handle the exceptions with exception handling, and inform the user of each exception with an appropriate message.

## Threads

* You might have time consuming functionality in your program, like...
  * heavy algorithms and mathematical calculations
  * reading a large amount of data from a file
* You could also have some continuous stream of data being read, like...
  * serial signal
* In case of time consuming methods, it might be a bad idea to wait for the execution to finish before continuing the main program
  * This would show up to the user as the program being stuck
  * At the very least, there could be some progress bar to indicate that the program hasn't crashed
* In the case of continuous execution, there needs to be some way to read the stream and execute the main program at the same time

## Threads (continued)

* .NET supports *__multithreading__* and classes to add new threads are included in the base class library
  ```csharp
  using System.Threading;
  ```
* Separate tasks can be executed simultaneously on separate  *__threads__*
* Separate threads run on different cores in the processor
* All threads have access to the resources allocated to your program

---

* Initialize a `ThreadStart` object with the method to be threaded as the argument:
  ```csharp
  public static void PrintInteger()
  ...
  ThreadStart printIntegerStart = new ThreadStart(PrintInteger);
  ```

* Initialize a `Thread` object with the `ThreadStart` object set as the argument, and start the new thread with `Thread.Start()` method:
  ```csharp
  Thread printIntegerThread = new Thread(printIntegerStart);
  printIntegerThread.Start();
  ```

## Thread example

<div class='columns21' markdown='1'>
<div markdown='1'>

```csharp
class Program
{
  public static void PrintInteger()
  {
    Console.WriteLine("Thread started.");
    int val = 0;
    while (true)
    {
      Thread.Sleep(100);
      Console.WriteLine("Current value: " + val);
      ++val;
    }
  }
  static void Main(string[] args)
  {
    ThreadStart printIntegerStart = new ThreadStart(PrintInteger);
    Console.WriteLine("Starting thread...");
    Thread printIntegerThread = new Thread(printIntegerStart);
    printIntegerThread.Start();
    Console.WriteLine("Main thread continuing.");
  }
}
```
</div>
<div markdown='1'>

The method prints a value, waits for $0.1\,\mathrm{s}$, increases the value, prints it again, etc.

The method keeps executing indefinitely, but the main thread continues execution as well!

![](imgs/14%20Exceptions%2C%20Threads%20and%20Tasks_3.png)

</div>
</div>

## Threads (continued)

* You can create as many threads as you like:

  ```csharp
  ThreadStart printIntegerStart = new ThreadStart(PrintInteger);
  Console.WriteLine("Starting thread...");

  Thread printIntegerThread = new Thread(printIntegerStart);
  printIntegerThread.Start();

  Thread printIntegerThread2 = new Thread(printIntegerStart);
  printIntegerThread2.Start();

  Thread printIntegerThread3 = new Thread(printIntegerStart);
  printIntegerThread3.Start();
  ```

## Exercise 2: Threaded Loading
<!-- _class: exercise -->

Create a method `public static void LoadData()` which simulates loading resources by printing progress from $0 \%$ to $100 \%$. Increase the progress in a loop with $1 \%$ increments. Use the `Thread.Sleep()` method to wait $10\,\mathrm{ms}$ between each increment.

Create a main loop where each time the user presses enter, the `LoadData()` method is executed on a separate thread.

![](imgs/14%20Exceptions%2C%20Threads%20and%20Tasks_4.png)

<!-- _footer: Näytä ekstrana, miten tämä tehdään käyttäen luokan metodia eri luokan arvoilla -->

## Tasks

* In some cases you want to continue working on some tasks while others are queued to be executed
  * For example, after sending a server request, you might want to begin some tasks immediately and others only after a response has been received
* Following  [this great analogy](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/async/)  from Microsoft docs, a cook doesn't have to wait for the eggs to be ready to begin brewing coffee or cooking bacon; instead, the cook would begin all tasks simultaneously
* Threading won't help here; even if there was one cook (thread) for each task, they would all have to wait for the oven to heat up. One cook can just well do all the tasks (cooking) alone.

# Tasks - Continued

* To create an asynchronous method, assign it with the async keyword. It is good practice to end the method name with Async
* The method should return a value of the type that is specified in the angled brackets (if your task doesn't return a value, leave the brackets out)
* Inside the method, call an asynchronous method with the await keyword:
  ```csharp
  static async Task<int> MyMethodAsync()
  {
    byte[] content = await client.GetByteArrayAsync("https://docs.microsoft.com/en-us/");
    return content.Length;
  }
  ```
* This method can now be called asynchronously:
  ```csharp
  Task<int> myMethodResult = MyMethodAsync();
  ```

## Tasks example


<div class='columns21' markdown='1'>
<div markdown='1'>

```csharp
class Program
{
  static async Task<string> GetResultAsync()
  {
    int waitTime = 5000;
    await Task.Delay(waitTime);
    // Replace above with some time-consuming async function
    return new string(
      $"The task took {waitTime / 1000} seconds to finish."
    );
  }
  static void Main(string[] args)
  {
    Console.WriteLine("Starting operation...");
    Task<string> resultTask = GetResultAsync();
    Console.WriteLine("Operation has been started.");
    Console.WriteLine("In the meantime, say something nice:");
    string somethingNice = Console.ReadLine();
    resultTask.Wait(); // Wait for the task to complete
    Console.WriteLine(resultTask.Result);
    Console.ReadKey();
  }
}
```

</div>
<div markdown='1'>

![](imgs/14%20Exceptions%2C%20Threads%20and%20Tasks_5.png)

</div>
</div>

## Exercise 3: Asynchronous Loading
<!-- _class: exercise -->

Redo exercise 2, but instead of using separate threads for "loading the data", use an asynchronous method `LoadDataAsync()`.

