Intro to Multithreading & Asynchrony

public static void Main(string[] args)
{
    var thread = new Thread(DisplayNumbers);
    thread.Start();
    DisplayNumbers();
}

private static void DisplayNumbers()
{
    Console.WriteLine("Starting...");
    for (int i = 1; i < 10; i++)
    {
        Console.WriteLine(i);
    }
}

static Boolean QueueUserWorkItem(WaitCallback callBack);
static Boolean QueueUserWorkItem(WaitCallback callBack, Object state);

delegate void WaitCallback(Object state);

public static void Main() {
    Console.WriteLine("Main thread: queue operation");
    ThreadPool.QueueUserWorkItem(ComputeBoundOp, 5);
    Console.WriteLine("Main thread: Doing other work");
    Thread.Sleep(10000); // Simulating other work (10 seconds)
    Console.WriteLine("Hit <Enter> to end this program...");
    Console.ReadLine();
}

private static void ComputeBoundOp(Object state) {
    Console.WriteLine("In ComputeBoundOp: state={0}", state);
    Thread.Sleep(1000); // Simulates other work (1 second)
}

public static class Monitor {
    public static void Enter(Object obj);
    public static void Exit(Object obj);
    public static Boolean TryEnter(Object obj, Int32 millisecondsTimeout);
    public static void Enter(Object obj, ref Boolean lockTaken);
    public static void TryEnter(Object obj, Int32 millisecondsTimeout, ref Boolean lockTaken);
}

public class Class1
{
    public void SomeMethod()
    {
        var pool = new Dictionary<int, int>();

        int i = 0;

        lock(pool) {
            ++i;
        }

        Console.WriteLine(i);
    }
}

void Main()
{
    var t1 = new Task(() => SomeAsyncOperation("Task 1"));
    var t2 = new Task(() => SomeAsyncOperation("Task 2"));
    t2.Start();
    t1.Start();
    var t3 = Task.Run(() => SomeAsyncOperation("Task 3"));
    var t4 = Task.Factory.StartNew(() => SomeAsyncOperation("Task 4"));
    var t5 = Task.Factory.StartNew(
        () => SomeAsyncOperation("Task 5"), 
        TaskCreationOptions.LongRunning);
    Task.WaitAll(new [] { t1, t2, t3, t4, t5 });
}

static void SomeAsyncOperation(string name)
{
    Console.WriteLine($"Task {name} is running on a thread id " +
        $"{Thread.CurrentThread.ManagedThreadId}. Is thread pool thread: " + 
        $"{Thread.CurrentThread.IsThreadPoolThread}");
}

void Main()
{
    TaskMethod("Main Thread Task");
    Task<int> t1 = CreateTask("Task 1");
    t1.Start();
    int task1Result = t1.Result;
    Console.WriteLine($"Result is: {task1Result}");
    var t2 = CreateTask("Task 2");
    t2.RunSynchronously();
    var task2Result = t2.Result;
    Console.WriteLine($"Result is: {task2Result}");

    var t3 = CreateTask("Task 3");
    Console.WriteLine(t3.Status);
    t3.Start();
    while (!t3.IsCompleted)
    {
        Console.WriteLine(t3.Status);
        Thread.Sleep(TimeSpan.FromSeconds(0.5));
    }
    Console.WriteLine(t3.Status);
    var t3Result = t3.Result;
    Console.WriteLine($"Result is: {t3Result}");
}

static Task<int> CreateTask(string name)
{
    return new Task<int>(() => TaskMethod(name));
}
static int TaskMethod(string name)
{
    Console.WriteLine(
        $"Task {name} is running on a thread id " +
        $"{Thread.CurrentThread.ManagedThreadId}. " + 
        "Is thread pool thread: " +
        $"{Thread.CurrentThread.IsThreadPoolThread}");
        Thread.Sleep(TimeSpan.FromSeconds(2));
    
    return 42;
}

void Main()
{
    TaskMethod("Main Thread Task");
    Task<int> t1 = CreateTask("Task 1");
    t1.Start();
    int task1Result = t1.Result;
    Console.WriteLine($"Result is: {task1Result}");
    var t2 = CreateTask("Task 2");
    t2.RunSynchronously();
    var task2Result = t2.Result;
    Console.WriteLine($"Result is: {task2Result}");
}

void Main()
{
    var t3 = CreateTask("Task 3");
    Console.WriteLine(t3.Status);
    t3.Start();
    while (!t3.IsCompleted)
    {
        Console.WriteLine(t3.Status);
        Thread.Sleep(TimeSpan.FromSeconds(0.5));
    }
    Console.WriteLine(t3.Status);
    var t3Result = t3.Result;
    Console.WriteLine($"Result is: {t3Result}");
}

void Main()
{
    var firstTask = new Task<int>(() => TaskMethod("First Task", 3));

    firstTask.ContinueWith(
        t => Console.WriteLine(
            $"The first answer is {t.Result}. Thread id " +
            $"{Thread.CurrentThread.ManagedThreadId}, is thread pool thread: " +
            $"{Thread.CurrentThread.IsThreadPoolThread}"),
        TaskContinuationOptions.OnlyOnRanToCompletion);

    firstTask.Start();
}

void Main()
{
    var firstTask = new Task<int>(() =>
    {
        var innerTask = Task.Factory.StartNew(
            () => TaskMethod("Second Task", 5), 
            TaskCreationOptions.AttachedToParent);

        innerTask.ContinueWith(
            t => TaskMethod("Third Task", 2), 
            TaskContinuationOptions.AttachedToParent);
        
        return TaskMethod("First Task", 2);
    });
    firstTask.Start();
    while (!firstTask.IsCompleted)
    {
        Console.WriteLine(firstTask.Status);
        Thread.Sleep(TimeSpan.FromSeconds(0.5));
    }
    
    Console.WriteLine(firstTask.Status);
}

public static int TaskMethod(
    string name, 
    int seconds,
    CancellationToken token)
{
    Console.WriteLine(
        $"Task {name} is running on a thread id " +
        $"{Thread.CurrentThread.ManagedThreadId}. Is thread pool thread: " +
        $"{Thread.CurrentThread.IsThreadPoolThread}");
    for (int i = 0; i < seconds; i++)
    {
        Thread.Sleep(TimeSpan.FromSeconds(1));
        if (token.IsCancellationRequested) return -1;
    }
    
    return 42 * seconds;
}

void Main()
{
    var cts = new CancellationTokenSource();
    var longTask = new Task<int>(() =>
        TaskMethod("Task 2", 10, cts.Token), 
        cts.Token);
        
    longTask.Start();
    for (int i = 0; i < 5; i++)
    {
        Thread.Sleep(TimeSpan.FromSeconds(0.5));
        Console.WriteLine(longTask.Status);
    }
    cts.Cancel();
    
    for (int i = 0; i < 5; i++)
    {
        Thread.Sleep(TimeSpan.FromSeconds(0.5));
        Console.WriteLine(longTask.Status);
    }
    Console.WriteLine($"A task has been completed with result {longTask.Result}.");
}

public async Task<int> DoSomethingAsync()
{
  var html = await _httpClient.DownloadStringAsync("http://dotnetfoundation.org");

  return html.Length;
}

public sealed class ContentProvider
{
    public string GetName()
    {
        Thread.Sleep(TimeSpan.FromSeconds(2));

        return "Something";
    }

    public int GetAge()
    {
        Thread.Sleep(TimeSpan.FromSeconds(5));

        return 42;
    }
    ...

    public async Task<string> GetNameAsync()
    {
        await Task.Delay(TimeSpan.FromSeconds(2));
    
        return "Something";
    }
    
    public async Task<int> GetAgeAsync()
    {
        await Task.Delay(TimeSpan.FromSeconds(5));
    
        return 77;
    }
}

private static Task<string> GetContentSync()
{
    var contentProvider = new ContentProvider();

    var name = contentProvider.GetName();
    var age = contentProvider.GetAge();

    return Task.FromResult($"{name} - {age}");
}

private static async Task<string> GetContentAsync()
{
    var contentProvider = new ContentProvider();

    var nameTask = contentProvider.GetNameAsync();
    var ageTask = contentProvider.GetAgeAsync();

    await Task.WhenAll(nameTask, ageTask);

    return $"{nameTask.Result} - {ageTask.Result}";
}

...
    public Task<int> GetAgeAsync()
    {
      ContentProvider.<GetAgeAsync>d__3 stateMachine = new ContentProvider.<GetAgeAsync>d__3();
      stateMachine.<>4__this = this;
      stateMachine.<>t__builder = AsyncTaskMethodBuilder<int>.Create();
      stateMachine.<>1__state = -1;
      stateMachine.<>t__builder.Start<ContentProvider.<GetAgeAsync>d__3>(ref stateMachine);
      return stateMachine.<>t__builder.Task;
    }
...

[CompilerGenerated]
private sealed class <GetAgeAsync>d__3 : IAsyncStateMachine
{
  public int <>1__state;
  public AsyncTaskMethodBuilder<int> <>t__builder;
  public ContentProvider <>4__this;
  private int <age>5__1;
  private int <newAge>5__2;
  private TaskAwaiter <>u__1;

  public <GetAgeAsync>d__3()
  {
    base..ctor();
  }

  void IAsyncStateMachine.MoveNext()
  {
    int num1 = this.<>1__state;
    int newAge52;
    try
    {
      TaskAwaiter awaiter;
      int num2;
      if (num1 != 0)
      {
        this.<age>5__1 = 55;
        this.<newAge>5__2 = this.<age>5__1 + 41;
        awaiter = Task.Delay(TimeSpan.FromSeconds(5.0)).GetAwaiter();
        if (!awaiter.IsCompleted)
        {
          this.<>1__state = num2 = 0;
          this.<>u__1 = awaiter;
          ContentProvider.<GetAgeAsync>d__3 stateMachine = this;
          this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter, ContentProvider.<GetAgeAsync>d__3>(ref awaiter, ref stateMachine);
          return;
        }
      }
      else
      {
        awaiter = this.<>u__1;
        this.<>u__1 = new TaskAwaiter();
        this.<>1__state = num2 = -1;
      }
      awaiter.GetResult();
      newAge52 = this.<newAge>5__2;
    }
    catch (Exception ex)
    {
      this.<>1__state = -2;
      this.<>t__builder.SetException(ex);
      return;
    }
    this.<>1__state = -2;
    this.<>t__builder.SetResult(newAge52);
  }

  [DebuggerHidden]
  void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
  {
  }
}