Home

using System;
using System.Threading;
using System.Threading.Tasks;

namespace TPL
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Start executing tasks.");

            #region 1. Creating tasks

            //1.1
            //Create a task.
            Task t1 = new Task(() => doWork(1));
            //Start the task.
            t1.Start();

            //1.2
            //Create and start a task at the same time.
            Task t2 = Task.Factory.StartNew(() => doWork(2)); 
            //As a side note: 
            //Here you can see a practical implementation of the factory software design patern. 
            //Instead of instantiating the Task class it gets made in the "factory" and is then returned to us.

            //1.3
            //This is how you can chain/schedule antother task after the previous one is finished.
            Task t3 = Task.Factory.StartNew(() => doWork(3)).ContinueWith((task) => doWork(4));

            //1.4
            Task<int> t4 = Task<int>.Factory.StartNew(() => doWork()); 
            //You can access the result of a completed task by accessing the "Result" property.
            Console.WriteLine("Task 4 result: " + t4.Result);

            #endregion


            #region 2. Waiting for tasks

            //4.
            //As you might have noticed in the console output "Done executing tasks." gets written out before any of the tasks have finsihed.
            //Well that is great in the sense that we don't have any thread blocking code. But what if we need to wait for a task to complete before continuing(like in the example above)?
            //You can pass an array of the tasks that you want to wait to finish to the AwaitAll() method.

            //Now task 1 and 2 will execute before "Done executing tasks." is printed to the console.
            Task[] tasks = { t1, t2 };
            Task.WaitAll(tasks);

            #endregion

            Console.WriteLine("Done executing tasks.");


            #region 5. Parellel for loops

            //Make some int arrays.
            int[] ar1 = new int[4] { 1, 5, 6, 8 };
            int[] ar2 = new int[4] { 7, 5, 5, 8 };
            int[] ar3 = new int[4] { 2, 3, 6, 3 };

            //Make an array of int arrays.
            int[][] arrays = new int[][] { ar1, ar2, ar3 };

            //Get and write out the sum for each array using For. (asynchronously)
            Parallel.For(0, 3, (i) => Console.WriteLine(sumArray(arrays[i])));

            //Get and write out the sum for each array using ForeEach. (asynchronously)
            Parallel.ForEach(arrays, (array) => Console.WriteLine(sumArray(array)));

            #endregion


            #region 6. Parallel Invoke

            //Using Parallel.Invoke you can start up multiple prallel tasks at once. 
            Parallel.Invoke(
                () => doWork(5),
                () => doWork(6),
                () => doWork(7)
            );

            #endregion


            #region 7. Cancelation token. 

            //If we want the ability to cancel a task we can implement a cancellation token to achive this.

            //Make a cancellation token.
            var cancel = new CancellationTokenSource();

            try
            {
                //Start a task chain.
                Task t5 = Task.Factory.StartNew(() => doWork(5, cancel.Token)).ContinueWith((task) => doWork(6, cancel.Token)).ContinueWith((task) => doWork(7, cancel.Token));

                //Simulate doing something ...        
                Thread.Sleep(4500);

                ///////////////////////////////

                //We decide that our tasks need to be canceled.
                cancel.Cancel();

            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            finally
            {
                cancel.Dispose();
            }

            #endregion

            Console.ReadLine();
        }

        //Sums all the integers in na int array.
        public static int sumArray(int[] array)
        {
            int sum = 0;

            foreach (int element in array)
                sum += element;

            return sum;
        }

        public static void doWork(int taskNumber)
        {
            Console.WriteLine("Task " + taskNumber + " has started.");

            //Simulate doing time consuming work.
            Thread.Sleep(4000);

            Console.WriteLine("Task " + taskNumber + " is done.");
        }

        public static int doWork()
        {
            //Simulate doing time consuming work.
            Thread.Sleep(4000);

            int result = 10;

            return result;
        }

        //This overloaded version of the doWork() method takes in a cancelation token.
        public static void doWork(int taskNumber, CancellationToken cancel)
        {
            //If the cancelation tooken was sent the task will cancel.
            if (cancel.IsCancellationRequested)
            {
                Console.WriteLine("Task " + taskNumber + " canceled.");
                cancel.ThrowIfCancellationRequested();
            }

            Console.WriteLine("Task " + taskNumber + " has started.");

            //Simulate doing time consuming work.
            Thread.Sleep(4000);

            Console.WriteLine("Task " + taskNumber + " is done.");
        }
    }
}