// Two equivalents lines
new Task(Compute, 5).Start();
ThreadPool.QueueUserWorkItem(Compute, 5);

Task<Int32> t = new Task<Int32>(Compute, 5);  //Int32 return type instead of void  
t.Start();  // Starts the task sometime later (puts the task in the queue)

//Block current thread waiting
t.Wait(); //overloads accept timeout/CancellationToken

t.Result //Get the result (Int32) & calls wait internally

// There are static methods WaitAll & WaitAny returned Task[]

var t = new Task<Int32>(Compute, 5);
t.Start();
//Ok
t.ContinueWith(t => Console.WriteLine(t.Result),
		TaskContinuationOptions.OnlyOnRanToCompletion);
//Exception
t.ContinueWith(t => Console.WriteLine(t.Exception),
		TaskContinuationOptions.OnlyOnFaulted);
//Cancellation
t.ContinueWith(t => Console.WriteLine("Canceled"),
		TaskContinuationOptions.OnlyOnCanceled);

private static Int32 Compute(Object state) {
	var ct = (CancellationToken) state;
	var result = 0;
	for (var n = 0; n < 10000; n++) {
		ct.ThrowIfCacellationRequested();
		// Do work here ...
	}
	return result;
}

var parent = new Task<Int32[]>( () => {
	var results = new Int32[2];
	new Task(() => results[0] = Sum(10000)).Start();
	new Task(() => results[1] = Sum(20000)).Start();
	return results;
});
parent.Start();

//Problem: this runs when parent finishes (but not its children)
parent.ContinueWith(t => Array.ForEach(t.Result, r => m_lb.Items.Add(r)));

	new Task(() => results[0] = Sum(10000),
		TaskCreationOptions.AttachedToParent).Start();

var ts = TaskScheduler.FromCurrentSynchronizationContext();
parent.ContinueWith(t => Array.ForEach(t.Result, r => m_lb.Items.Add(r)), ts);

var solution = new Task(() => {
	var tf = new TaskFactory(
		TaskcreationOptions.AttachedToParent,
		TaskContinuationOptions.AttachedToParent);

	var D = tf.StartNew(() => Compile("D"));
	var E = tf.StartNew(() => Compile("E"));
	var F = tf.StartNew(() => Compile("F"));

	var B = D.ContinueWith(t => Compile("B"));
	var C = tf.ContinueWhenAll(new Task[]{E, F}, task => Compile("C"));
	var A = tf.ContinueWhenAll(new Task[]{B, C}, task => Compile("A"));
});

solution.Start();

//Static For
for (Int32 i=0; i<1000; i++) DoWork(i);
Parallel.For(0, 1000, i=>DoWork(i));

//Static ForEach
for (var item in collection) DoWork(item);
Parallel.ForEach(collection, item => DoWork(item));

// Invoke parallel works
DoWork1(); DoWork2(); DoWork3();
Parallel.Invoke(() => DoWork1(), () => DoWork2(), () => DoWork3());

internal static class TimerDemo {
	private static Timer s_timer;
	public static void Main(){
		Console.WriteLine("Checking status every 2 seconds:");
		s_timer = new Timer(Status, null, 0, 2000);
		Console.ReadLine();
	}
	private static void Status(Object state){
		// Chack status code here ....
	}
}

internal static class TimerDemo {
	private static Timer s_timer;
	public static void Main(){
		Console.WriteLine("Checking status every 2 seconds:");
		s_timer = new Timer(Status, null, 0, Timeout.infinite); //No 2000
		Console.ReadLine();
	}
	private static void Status(Object state){
		// Chack status code here ....

		// Have the Time call this method again in 2 seconds
		s_timer.Change(2000, Timeout.infinite);
	}
}

internal static class TimerDemo {
	private static Timer s_timer;
	public static void Main(){
		Console.WriteLine("Checking status every 2 seconds:");
		s_timer = new Timer(Status, null, Timeout.infinite, Timeout.infinite); //Change
		s_timer.Change(0, Timeout.infinite); //Change
		Console.ReadLine();
	}
	private static void Status(Object state){
		// Chack status code here ....

		// Have the Time call this method again in 2 seconds
		s_timer.Change(2000, Timeout.infinite);
	}
}

//async create an state ma chine with stop & resume states
private static async Task<Int32> HttpLengthAsync(string uri){
	var text = await new HttpClient().GetStringAsync(uri);
	//At await machine stops & resume with the result
	return text.Length
	//return put the value in the Result methos of the task
}

//Equivalent
private static async Task<Int32> HttpLengthAsync(string uri){
	Task<string> task = new HttpClient().GetStringAsync(uri);
	vat text = await task;
	return text.Length;
}

    public static async Task<string> IssueClientRequestAsync(string serverName, string msg)
    {

        using (var pipe = new NamedPipeClientStream(serverName, "PipeName",
            PipeDirection.InOut, PipeOptions.Asynchronous))
        {

            pipe.Connect(); //before setting read mode
            pipe.ReadMode = PipeTransmissionMode.Message;

            //Asynchronously sen data to the server
            Byte[] request = Encoding.UTF8.GetBytes(msg);
            await pipe.WriteAsync(request, 0, request.Length);
            // will return a Task<string> immediatly to function caller

            //Asynchronously read the server's response
            Byte[] response = new Byte[1000];
            Int32 bytesRead = await pipe.ReadAsync(response, 0, response.Length);
            return Encoding.UTF8.GetString(response, 0, bytesRead);
            //** not return to function caller, instead puts in the result of Task
        }
    }

    public static async Task Go()
    {
        var requests = new List<Task<string>>(10000);
        for (Int32 n = 0; n < requests.Capacity; n++)
            requests.Add(IssueClientRequestAsync("localhost", "Request #" + n));

        string[] responses = await Task.WhenAll(requests);

        for (Int32 n = 0; n < responses.Length; n++)
            Console.WriteLine(responses[n]);
    }

    public static async Task Go(int loops)
    {
        var requests = new List<Task<string>>(loops);
        for (Int32 n = 0; n < requests.Capacity; n++)
            requests.Add(Part3_NamedPipeClient
                .IssueClientRequestAsync("localhost", "Request #" + n));

        // Continue as EACH task completes
        while (requests.Count > 0)
        {
            var responseTask = await Task.WhenAny(requests);
            requests.Remove(responseTask);
            Console.WriteLine(responseTask.Result);
        }
    }

	async void OnSuspending(object sender, SuspendingEventArgs e) {
        // A dewferral tells Windows you're returning but not done
        var deferral = e.Suspendingoperation.GetDeferral();
        // TODO: perform async operation(s) here ...
        var result = await xxxAsync();
        deferral.Complete();  //Now, tell Windows we're done
	}

namespace Wintellect.AwaitableEvent {
   public sealed class AwaitableEvent<TEventArgs> {
      private TaskCompletionSource<AwaitableEventArgs<TEventArgs>> m_tcs;

      // Returns an (awaitable) Task; set when EventHandler is invoked
      public Task<AwaitableEventArgs<TEventArgs>> RaisedAsync(Object state = null) {
         if (m_tcs == null)
            m_tcs = new TaskCompletionSource<AwaitableEventArgs<TEventArgs>>(state);
         return m_tcs.Task;
      }

      // Invoked when event is raised
      public void Handler(Object sender, TEventArgs eventArgs) {
         if (m_tcs == null) return;
         // We use the temporary variable (tcs) & reset m_tcs to null before calling
         // SetResult because SetResult returns from await immediately which may
         // call RaisedAsync again and we need this to create a new TaskCompletionSource
         var tcs = m_tcs; m_tcs = null;
         tcs.SetResult(new AwaitableEventArgs<TEventArgs>(sender, eventArgs));
      }
   }

   public sealed class AwaitableEventArgs<TEventArgs> {
      public readonly Object Sender;
      public readonly TEventArgs Args;
      internal AwaitableEventArgs(Object sender, TEventArgs args) {
         Sender = sender;
         Args = args;
      }
   }
}

private sealed class LinkedList{
	private var m_lock = new SomeKindOfLock();
	private Node m_head;

	public void Add(Node node){
		m_lock.Acquire();
		newNode.m_next = m_head;
		m_head = newNode;
		m_lock.Release();
	}
}