posted by Rafael

posted by shaggygi

posted by Sam

Professor Jones, totally.

posted by einarwh

posted by diryboy

posted by Chubbaca

posted by Lukasz

posted by DoubleUSeeF

Charles, you should get Mads together with Brian Beckerman/Bart de Smet/Eric Meier and do "Monads & Async jam" - it would be no fun if there were no monads

posted by Kyrae

3 hours ago, Kyrae wrote

Very nice stuff.

Charles, you should get Mads together with Brian Beckerman/Bart de Smet/Eric Meier and do "Monads & Async jam" - it would be no fun if there were no monads

I do want to get Mads on 9 more often. He's a great conversationalist! Would be great to get Brian and Erik's perspective on this new language feature. Actually, you can get a glimpse of this (in terms of Erik) in the C9 Live piece with Erik and Wolfram Schulte. It's available at http://microsoftpdc.com (check out the C9 Live on-demand stuff in the player).

C

posted by Charles

class DispatchThreadsAsync
{
  static void Main()
    {
      const int maxThreadCount = Enviroment.ProcessorCount;
      var workToBeDone  = new List<Task>();
      int threadNumber = 1;
      while (thread < CONCURRENCY && thread != 0)
      {
        foreach (int workItem in workToBeDone)
        {
          async workToBeDone.Add(ScheduleNextThreadAsync( threadNumber , workItem ));
        }
        threadNumber = thread.nextAvailableThread();
      }
   }
}

So I mean that to capture a dynamically scheduled loop method thingy that schedules un-even workloads as threads onto cores which become available. Asynchronously creating/reusing/receiving thread tasks per work item in a work queue as long as work is available.

To me that would be a cool way to dynamically dispatch newly created work items and threads.  And I'd suggest that the C# team see if this type of method for creating tasks of work to be done could be made into a nice little industrial-strength official C# 5.0 asynchronous task method

As I said im no C# coder but I tried my best to pseudo-C# my point across by what I think would be a good abstraction unless it already exists of course and I haven't looked hard enough

posted by HeavensRevenge

public async Task<List<Result>> GetResults()
{
    var results = new List<Result>();
    foreach (var url in urls )
    {
         UnprocessedResult r = await DownloadResult(url);
         results.Add( processResult(r) );
    }
    return results;
} 

But then to get the improved parallelism that they talk about in the video, you want to use WhenAll, so you do this:

public async Task<List<Result>> GetResults()
{
    var results = new List<Result>();
    var tasks = new List<Task<result>>();
    foreach (var url in urls )
    {
         tasks.Add (DownloadResult(url));
    }
    await Task.WhenAll(tasks);
    foreach (var t in tasks)
    {
         results.Add( processResult(t.Result) );
     }
    return results;
} 

The problem is the fact that we have to do the "continuation" of each task in a separate loop. One way of fixing this is to move the loop body out into its own async method which awaits DownloadResult and then processes it afterwards. Then the main function can just WaitAll on *those* tasks. But having to create a brand new method for tiny "post-async-fixups" is onerous. It would be cool if we could just create async lambdas, which we then call immediately, which then returns a task with the body inside it. E.g.:

public async Task<List<Result>> GetResults()
{
    var results = new List<Result>();
    var tasks = new List<Task<UnprocessedResult>>();

    foreach (var url in urls )
    {
         // notice async lambda, that gets called immediately
         tasks.Add( async () => {
                 var r = await DownloadResult(url);
                results.Add( processResult( r ) );
         }() );        
    }

    await Task.WhenAll( tasks );
    return results;
} 

You can't call a lambda like that, so even with async lambdas it would be ugly:

public async Task<List<Result>> GetResults()
{
    var results = new List<Result>();
    var tasks = new List<Task<UnprocessedResult>>();

    foreach (var url in urls )
    {
         // notice async lambda, that gets called immediately
         Func<Task<UnprocessedResult>> f = async () => {
                 var r = await DownloadResult(url);
                results.Add( processResult( r ) );
         };
         tasks.Add( f() );        
    }

    await Task.WhenAll( tasks );
    return results;
}

Perhaps an alternate syntax which does the above would be in order?

public async Task<List<Result>> GetResults()
{
    var results = new List<Result>();
    var tasks = new List<Task<UnprocessedResult>>();

    foreach (var url in urls )
    {
         tasks.Add( async {
                 var r = await DownloadResult(url);
                results.Add( processResult( r ) );
         });        
    }

    await Task.WhenAll( tasks );
    return results;
}

Where "async{ ...}" just whips up a simple local Task that does the stuff in the body.

posted by ssylvan

posted by Eric Lippert

posted by Yury Serdyuk

posted by Harrison Ford