并行算法中的异常

   public  class AsyncTask
    {
       public void TestMethod()
       {
           List<string> Listone = new List<string> { "url2","url","urle"};
           //var results = from url in Listone.AsParallel()
           //              select new WebClient().DownloadData(url);
           //results.ForAll(result=>Userresult(result));
           try
           {
               Listone.RunAsync(url => StartDownload(url), task => FinishDownLoad(task.AsyncState.ToString(), task.Result));
           }
           catch(AggregateException problems)
           {
               var handers = new Dictionary<Type, Action<Exception>>();
               handers.Add(typeof(Exception),ex=>Console.WriteLine(ex.Message));
               if (!HandleAggregateError(problems, handers))
                   throw;
           }

       }
       private static bool HandleAggregateError(AggregateException aggregate,Dictionary<Type,Action<Exception>> exceptionHanders)
       { 
          foreach(var exception in aggregate.InnerExceptions)
          {
              if (exception is AggregateException)
                  return HandleAggregateError(exception as AggregateException, exceptionHanders);
              else if (exceptionHanders.ContainsKey(exception.GetType()))
              {
                  exceptionHanders[exception.GetType()](exception);
              }
              else
                  return false;

             
          }
          return true;
       }

       private void Userresult(byte[] result)
       {
           return;
       }
       private static void FinishDownLoad(string url,byte[] bytes)
       {
           Console.WriteLine("Read{0} byes from {1}",bytes.Length,url);
       }
       private static Task<byte[]> StartDownload(string url)
       {
           var tcs = new TaskCompletionSource<byte[]>(url);
           var wc = new WebClient();
           wc.DownloadDataCompleted += (sender, e) =>
               {
                   if (e.UserState == tcs)
                   {
                       if (e.Cancelled)
                       {
                           tcs.TrySetCanceled();
                       }
                       else if (e.Error != null)
                       {
                           if (e.Error is WebException)
                               tcs.TrySetResult(new byte[0]);
                           else
                               tcs.TrySetException(e.Error);
                       }
                       else
                           tcs.TrySetResult(e.Result);
                   }

               };

           wc.DownloadDataAsync(new Uri(url),tcs);
           return tcs.Task;
       }
    }
   public static class MyExtenion
   {
       public static void RunAsync<T, TResult>(this IEnumerable<T> taskParms, Func<T, Task<TResult>> tasStarter, Action<Task<TResult>> taskFinisher)
       {
           taskParms.Select(parm => tasStarter(parm)).AsParallel().ForAll(t => t.ContinueWith(t2 => taskFinisher(t2)));

       }
   }