// fire and forget
interface IOperation
{
  Task Fire();
}
// some consumer code
IOperation operation;
void MyCoolCode(IOperation operation)
{
  operation.Fire();
}

warning CS4014: Because this call is not awaited,
execution of the current method continues before the
call is completed. Consider applying the 'await'
operator to the result of the call.

// fire and forget
interface IOperation
{
  Task Fire();
}
// some consumer code
IOperation operation;
async void MyCoolCode(IOperation operation)
{
  await operation.Fire();
}

async Task DoStuff(CancellationToken token)
{
  await ...
  token.ThrowIfCancellationRequested();
  for ()
  {
    await ...
    token.ThrowIfCancellationRequested();
  }
}

try
{
  await...
}
catch (OperationCancelledException)
{
  // cancelled
}
catch
{
  // errored!
}
* >

var file = File.Create("out.txt");
var bytes = Encoding.UTF8.GetBytes("hello world");
file.BeginWrite(bytes, 0, bytes.Length, ar =>
{
    file.EndWrite(ar);
}, null);

var file = File.Create("out.txt");
var bytes = Encoding.UTF8.GetBytes("hello world");
file.BeginWrite(bytes, 0, bytes.Length, ar =>
{
    file.EndWrite(ar);
    // Do it here
    file.Close();
}, null);

using (var file = File.Create("out.txt"))
{
    var bytes = Encoding.UTF8.GetBytes("hello world");
    file.BeginWrite(bytes, 0, bytes.Length, ar =>
    {
        file.EndWrite(ar);
    }, null);
}

// write them in exact order!
foreach (var fileName in fileNames)
{
    var bytes = Encoding.UTF8.GetBytes("hello world");
    file.BeginWrite(bytes, 0, bytes.Length, ar =>
    {
        file.EndWrite(ar);
    }, null);
}

var client = new WebClient();
client.DownloadStringAsync(new Uri("https://e-conomic.com"));
client.DownloadStringCompleted += Client_DownloadStringCompleted;
private void Client_DownloadStringCompleted(
  object sender,
  DownloadStringCompletedEventArgs e)
{
    var html = e.Result;
}

var task = GetMeSomeTask();
task.ContinueWith(t =>
{
  var result = t.Result;
});

var client = new WebClient();
var task = client.DownloadStringTaskAsync(...);
task.ContinueWith(t =>
{
    var html = t.Result;
});

var client = new WebClient();
Task<string> task = client.DownloadStringTaskAsync(...);
Task<int> length = task.ContinueWith(t =>
{
    var html = t.Result;
    return html.Length;
});

var client = new WebClient();
var task = client.DownloadStringTaskAsync(...);
return task
  .ContinueWith(t =>
  {
      var html = t.Result;
      return html.Length;
  })
  .ContinueWith(t =>
  {
    var length = t.Result;
    // be creative here
  });

var promise = getData()
  .then(onSuccess)
  .catch(onFail);

public class Downloader : IDisposable
{
    private HttpClient client;
    public Downloader()
    {
        this.client = new HttpClient();
    }
    public void Dispose()
    {
        client.Dispose();
    }
    public Task<string> Fetcher(string subpath,
               CancellationToken cancellationToken)
    {
        return client.GetStringAsync("baseUri" + subpath)
            .ContinueWith(t =>
            {
                cancellationToken.ThrowIfCancellationRequested();
                return t.Result;
            });
    }
}

// Challenge! Convert to async
public static void Copy(Stream a, Stream b)
{
    var bytes = new byte[32];
    var offset = 0;
    int count;
    while ((count = a.Read(bytes, offset, 32)) > 0)
    {
        b.Write(bytes, offset, count);
        offset += count;
    }
}

public Task DoAsync()
{
  // some code
  int i = 0;
  task
    .ContinueWith(t =>
    {
      // some code that uses result...
      i = 1;
    })
    .ContinueWith(t =>
    {
      // some code that uses second result...
      i = -1;
    });
}

public Task DoAsync()
{
  // some code
  int i = 0;
  var result1 <== task;
  // some code that uses result...
  i = 1;
  var result2 <== task2;
  // some code that uses second result...
  i = -1;
}

public async Task DoAsync()
{
  // some code
  int i = 0;
  var result1 = await task;
  // some code that uses result...
  i = 1;
  var result2 = await task2;
  // some code that uses second result...
  i = -1;
}

// I don't care about thread
async Task Foo() => await Inner().ConfigureAwait(false);
// I don't care, but forgot to tell that!
async Task Inner() => await DeepCall();
// library also doesn't care about thread
async Task DeepCall() => await WeMustGoDeeper().ConfigureAwait(false);

var result = await Task.Run(AnalyzeData);

var result = await Task.Run(async () =>
{
    await Task.Delay(0);
    return 1;
});
var result = await Task.Factory.StartNew(async () =>
{
    await Task.Delay(0);
    return 1;
}).Unwrap();

public static Task<T> WithTimeout<T>(this Task<T> task, int timeout)
{
    var t = Task.Delay(timeout);
    var first = Task.WhenAny(task, t);
    if (first == t)
        throw new Exception();
    return Task.FromResult(task.Result);
}

private async void Button_Click_3(object sender, RoutedEventArgs e)
{
    var client = new HttpClient();
    await client.GetStringAsync("https://secure.e-conomic.com");
}

Task throttle = null;
CancellationTokenSource cts = new CancellationTokenSource();
private void Button_Click_3(object sender, RoutedEventArgs e)
{
    if (throttle != null)
    {
        cts.Cancel();
    };
    cts = new CancellationTokenSource();
    throttle = Task.Delay(500, cts.Token);
    throttle.ContinueWith(
      t => Download(),
      TaskContinuationOptions.OnlyOnRanToCompletion);
}
async Task Download()
{
    var client = new HttpClient();
    await client.GetStringAsync("https://secure.e-conomic.com");
}

Task<IEnumerable<T>> list;
foreach (var element in await list)
{
  // only runs once everything is retrieved!
}

static async Task Main(string[] args)
{
    await foreach (var html in Downloader(
      "http://e-conomic.com",
      "http://secure.e-conomic.com"))
    {
        Console.WriteLine($"HTML: {html.Substring(0, 10)}");
    }
}
static async IAsyncEnumerable<string> Downloader(params string[] urls)
{
    foreach (var url in urls)
    {
        Console.WriteLine($"Fetching {url}");
        yield return await new HttpClient().GetStringAsync(url);
    }
}