async await (again) inside lambda - task-parallel-library

Question

I was reading a few blogs about async & await, particularly that of Scott's blog . I have a code sample below, which presumably downloads a list of URLs. To simplify things and make the timings reasonable and repeatable, I replaced the real download code with a Task.Delay awaitable call.
The first code doesn't have an async-await pair inside the lambda expression, while the second one has. Both codes compile, and both timings come out the same (around 1 second).
1.) Which method is the right way to do this?
2.) Will the await async pair inside the lambda cost more?
private async void Button_Click(object sender, RoutedEventArgs e)
{
// Capture the UI synchronization context for use later
var ui = TaskScheduler.FromCurrentSynchronizationContext();
// SAMPLE 1 , is this the right way?
var items = Enumerable.Range(1, 100).Select(i => i.ToString()).ToList();
var sp = new Stopwatch();
sp.Start();
// NO await async pair in lambda
var results1 = await Task.WhenAll(
items.Select(item => DownloadFileAsync(item)));
sp.Stop();
var testResult = string.Format("Single await: {0} seconds"
, sp.Elapsed.TotalSeconds);
// SAMPLE 2, or this way?
var items1 = Enumerable.Range(1, 100).Select(i => i.ToString()).ToList();
var sp1 = new Stopwatch();
sp1.Start();
// WITH await async pair in lambda
var results = await Task.WhenAll(items1.Select(async item =>
await DownloadFileAsync(item)));
sp1.Stop();
var testResult1 = string.Format("Double await: {0} seconds",
sp1.Elapsed.TotalSeconds);
// show results
await Task.Factory.StartNew(() =>
{
MessageBox.Show(testResult + System.Environment.NewLine + testResult1);
}, CancellationToken.None, TaskCreationOptions.None,
ui).ConfigureAwait(false);
}
and
private async Task<string> DownloadFileAsync(string uri)
{
//using (var client = new WebClient())
//{
// string data = await
client.DownloadStringTaskAsync(uri).ConfigureAwait(false);
// return data;
//}
await Task.Delay(1000).ConfigureAwait(false);
return uri;
}

Answer 1

Both of them are roughly equivalent. The first one is slightly more efficient.
For the purposes of this question, you can think of
await as "unwrapping" a task, and
async as "wrapping" a method in a task.
The first example uses a lambda expression to define a function with the signature Task<string> F(string). The function defined by the second example has the same signature. The difference is that
the first example just returns the task from DownloadFileAsync directly
while the second example unwraps the task and then wraps it again.