using System;

using System.Runtime.InteropServices;
using System.Threading;
using System.Threading.Tasks;

namespace IntroducingTasks
{
class CancelingTasks
{
static void Main(string[] args)
{
CancelableTasks();
MonitoringCancelation();
CompositeCancelationToken();

Console.WriteLine("Main program done, press any key.");

Console.ReadKey();
}

private static void WaitingForTimeToPass()

{
// we've already seen the classic Thread.Sleep

var cts = new CancellationTokenSource();

var token = cts.Token;
var t = new Task(() =>
{
Console.WriteLine("You have 5 seconds to disarm this bomb by pressing a
key");
bool canceled = token.WaitHandle.WaitOne(5000);
Console.WriteLine(canceled ? "Bomb disarmed." : "BOOM!!!!");
}, token);
t.Start();

// unlike sleep and waitone

// thread does not give up its turn
Thread.SpinWait(10000);
Console.WriteLine("Are you still here?");

Console.ReadKey();
cts.Cancel();
}

private static void CompositeCancelationToken()

{
// it's possible to create a 'composite' cancelation source that involves
several tokens
var planned = new CancellationTokenSource();
var preventative = new CancellationTokenSource();
var emergency = new CancellationTokenSource();

// make a token source that is linked on their tokens

var paranoid = CancellationTokenSource.CreateLinkedTokenSource(
planned.Token, preventative.Token, emergency.Token);

Task.Factory.StartNew(() =>
{
int i = 0;
while (true)
 {
paranoid.Token.ThrowIfCancellationRequested();
Console.Write($"{i++}\t");
Thread.Sleep(100);
}
}, paranoid.Token);

paranoid.Token.Register(() => Console.WriteLine("Cancelation requested"));

Console.ReadKey();

// use any of the aforementioned token soures

emergency.Cancel();
}

private static void MonitoringCancelation()

{
var cts = new CancellationTokenSource();
var token = cts.Token;

// register a delegate to fire

token.Register(() =>
{
Console.WriteLine("Cancelation has been requested.");
});

Task t = new Task(() =>

{
int i = 0;
while (true)
{
if (token.IsCancellationRequested) // 1. Soft exit
// RanToCompletion
{
break;
}
else
{
Console.Write($"{i++}\t");
Thread.Sleep(100);
}
}
});
t.Start();

// canceling multiple tasks

Task t2 = Task.Factory.StartNew(() =>
{
char c = 'a';
while (true)
{
// alternative to what's below
token.ThrowIfCancellationRequested(); // 2. Hard exit, Canceled

if (token.IsCancellationRequested) // same as above, start HERE

{
// release resources, if any
throw new OperationCanceledException("No longer interested in printing
letters.");
 }
else
{
Console.Write($"{c++}\t");
Thread.Sleep(200);
}
}
}, token); // don't do token, show R# magic

// cancellation on a wait handle

Task.Factory.StartNew(() =>
{
token.WaitHandle.WaitOne();
Console.WriteLine("Wait handle released, thus cancelation was requested");
});

Console.ReadKey();

cts.Cancel();

Thread.Sleep(1000); // cancelation is non-instant

Console.WriteLine($"Task has been canceled. The status of the canceled task

't' is {t.Status}.");
Console.WriteLine($"Task has been canceled. The status of the canceled task
't2' is {t2.Status}.");
Console.WriteLine($"t.IsCanceled = {t.IsCanceled}, t2.IsCanceled =
{t2.IsCanceled}");
}

private static void CancelableTasks()

{
var cts = new CancellationTokenSource();
var token = cts.Token;
Task t = new Task(() =>
{
int i = 0;
while (true)
{
if (token.IsCancellationRequested) // task cancelation is cooperative,
no-one kills your thread
break;
else
Console.WriteLine($"{i++}\t");
}
});
t.Start();

// don't forget CancellationToken.None

Console.ReadKey();
cts.Cancel();
Console.WriteLine("Task has been canceled.");
}
}
}