asp.net C＃4.0で非同期メソッドを呼び出すにはどうすればよいですか？

私は、.net 4.5には、非同期メソッドの呼び出しを容易にする非同期キーワードがあります。私は現在、C＃4.0で非同期呼び出しを行う方法を研究しています。私がしたい例は、データグリッドがデータバインドされている非同期呼び出しを行うことです。asp.net C＃4.0で非同期メソッドを呼び出すにはどうすればよいですか？

私にいくつかのリンクを提供できれば、本当に感謝しています。

出典

2012-11-07 Randel Ramirez

タスクを使ってみると、これは.Net 4で利用でき、役立つはずです。簡単な例は次のようになります。詳しくは

 public void MainFlow() 
    { 
     Task taskWork = Task.Factory.StartNew(new Action(DoWork)); 

     //Do other work 


     //Then wait for thread finish 
     taskWork.Wait(); 
    } 


    private void DoWork() 
    { 
     //Do work 
    }

を、ここで見て

http://msdn.microsoft.com/en-us/library/system.threading.tasks.task(v=vs.100).aspx

出典

2012-11-07 09:05:03

Task.Runは.Net 4.0には存在しません。 – JPProgrammer

.Net 4用Task.Factory.StartNewを使用します。 –

タスクが完了すると、基本的にはあなたのアクションを実行Task.ContinueWithを使用してください。

役に立つかもしれませんいくつかの例：

http://msdn.microsoft.com/en-us/library/dd784422.aspx

出典

2012-11-07 09:07:46 sam1589914

私たちは、非同期操作を実行するためのいくつかのツールクラスを作りました。

これらのメソッドが実際に行うこと：アクションを非同期で実行し、同期コンテキストに応じて完了の実行をポストします。

長時間実行する操作を呼び出すときに、WPFを簡単に使用するためにこれをTPLのラッパーとして作成しました。このクラスには、放棄されただけでなく取り消すことのできるアクションの類似点もあります。

public static class AsyncExecutor 
    { 
     public static CancellationTokenSource ExecuteBlockingOperation(Action action, Action completition, Action<AggregateException> onException) 
     { 
      if (action == null) 
       throw new ArgumentNullException("action"); 

      if (completition == null) 
       throw new ArgumentNullException("completition"); 

      var cts = new CancellationTokenSource(); 
      var token = cts.Token; 

      var scheduler = TaskScheduler.FromCurrentSynchronizationContext(); 

      var task = new Task(action, TaskCreationOptions.LongRunning); 
      task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler); 
      task.ContinueWith(asyncPart => 
            { 
             if (!token.IsCancellationRequested) 
              completition(); 
            }, 
           CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler); 
      task.Start(); 

      return cts; 

     } 

     public static CancellationTokenSource ExecuteBlockingOperation<TIn>(Action<TIn> action, TIn parameter, Action<TIn> completition, Action<AggregateException, TIn> onException) 
     { 
      if (action == null) 
       throw new ArgumentNullException("action"); 

      if (completition == null) 
       throw new ArgumentNullException("completition"); 

      var cts = new CancellationTokenSource(); 
      var token = cts.Token; 

      var scheduler = TaskScheduler.FromCurrentSynchronizationContext(); 

      var task = new Task(() => action(parameter), TaskCreationOptions.LongRunning); 
      task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception, parameter), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler); 
      task.ContinueWith(asyncPart => 
            { 
             if (!token.IsCancellationRequested) 
              completition(parameter); 
            }, 
           CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler); 
      task.Start(); 

      return cts; 

     } 

     public static CancellationTokenSource ExecuteBlockingOperation<TOut>(Func<TOut> func, Action<TOut> completition, Action<AggregateException> onException) 
     { 
      if (func == null) 
       throw new ArgumentNullException("func"); 

      if (completition == null) 
       throw new ArgumentNullException("completition"); 

      var cts = new CancellationTokenSource(); 
      var token = cts.Token; 

      var scheduler = TaskScheduler.FromCurrentSynchronizationContext(); 

      var task = new Task<TOut>(func, TaskCreationOptions.LongRunning); 
      task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler); 
      task.ContinueWith(asyncPart => 
            { 
             if (!token.IsCancellationRequested) 
              completition(asyncPart.Result); 
            }, 
           CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler); 
      task.Start(); 

      return cts; 

     } 

     public static CancellationTokenSource ExecuteBlockingOperation<TIn, TOut>(Func<TIn, TOut> func, TIn parameter, Action<TOut, TIn> completition, Action<AggregateException, TIn> onException) 
     { 
      if (func == null) 
       throw new ArgumentNullException("func"); 

      if (completition == null) 
       throw new ArgumentNullException("completition"); 

      var cts = new CancellationTokenSource(); 
      var token = cts.Token; 

      var scheduler = TaskScheduler.FromCurrentSynchronizationContext(); 

      var task = new Task<TOut>(() => func(parameter), TaskCreationOptions.LongRunning); 
      task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception, parameter), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler); 
      task.ContinueWith(asyncPart => 
      { 
       if (!token.IsCancellationRequested) 
        completition(asyncPart.Result, parameter); 
      }, 
           CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler); 
      task.Start(); 

      return cts; 
     } 

     public static CancellationTokenSource ExecuteBlockingOperation<TIn, TOut>(Func<TIn, TOut> func, TIn parameter, Action<TOut> completition, Action<AggregateException, TIn> onException) 
     { 
      if (func == null) 
       throw new ArgumentNullException("func"); 

      if (completition == null) 
       throw new ArgumentNullException("completition"); 

      var cts = new CancellationTokenSource(); 
      var token = cts.Token; 

      var scheduler = TaskScheduler.FromCurrentSynchronizationContext(); 

      var task = new Task<TOut>(() => func(parameter), TaskCreationOptions.LongRunning); 
      task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception, parameter), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler); 
      task.ContinueWith(asyncPart => 
      { 
       if (!token.IsCancellationRequested) 
        completition(asyncPart.Result); 
      }, 
           CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler); 
      task.Start(); 

      return cts; 
     } 

     public static CancellationTokenSource ExecuteBlockingOperation<TIn, TOut>(Func<TIn, TOut> func, TIn parameter, Action<TIn> completition, Action<AggregateException, TIn> onException) 
     { 
      if (func == null) 
       throw new ArgumentNullException("func"); 

      if (completition == null) 
       throw new ArgumentNullException("completition"); 

      var cts = new CancellationTokenSource(); 
      var token = cts.Token; 

      var scheduler = TaskScheduler.FromCurrentSynchronizationContext(); 

      var task = new Task<TOut>(() => func(parameter), TaskCreationOptions.LongRunning); 
      task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception, parameter), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler); 
      task.ContinueWith(asyncPart => 
      { 
       if (!token.IsCancellationRequested) 
        completition(parameter); 
      }, 
           CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler); 
      task.Start(); 

      return cts; 
     } 

     public static CancellationTokenSource ExecuteBlockingOperation<TIn, TOut>(Func<TIn, TOut> func, TIn parameter, Action completition, Action<AggregateException, TIn> onException) 
     { 
      if (func == null) 
       throw new ArgumentNullException("func"); 

      if (completition == null) 
       throw new ArgumentNullException("completition"); 

      var cts = new CancellationTokenSource(); 
      var token = cts.Token; 

      var scheduler = TaskScheduler.FromCurrentSynchronizationContext(); 

      var task = new Task<TOut>(() => func(parameter), TaskCreationOptions.LongRunning); 
      task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception, parameter), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler); 
      task.ContinueWith(asyncPart => 
      { 
       if (!token.IsCancellationRequested) 
        completition(); 
      }, 
           CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler); 
      task.Start(); 

      return cts; 
     } 

     public static CancellationTokenSource ExecuteBlockingOperation<TIn, TOut>(Func<TIn, TOut> func, TIn parameter, Action<TIn> completition, Action<AggregateException> onException) 
     { 
      if (func == null) 
       throw new ArgumentNullException("func"); 

      if (completition == null) 
       throw new ArgumentNullException("completition"); 

      var cts = new CancellationTokenSource(); 
      var token = cts.Token; 

      var scheduler = TaskScheduler.FromCurrentSynchronizationContext(); 

      var task = new Task<TOut>(() => func(parameter), TaskCreationOptions.LongRunning); 
      task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler); 
      task.ContinueWith(asyncPart => 
      { 
       if (!token.IsCancellationRequested) 
        completition(parameter); 
      }, 
           CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler); 
      task.Start(); 

      return cts; 
     } 

     public static CancellationTokenSource ExecuteBlockingOperation<TIn, TOut>(Func<TIn, TOut> func, TIn parameter, Action<TOut, TIn> completition, Action<AggregateException> onException) 
     { 
      if (func == null) 
       throw new ArgumentNullException("func"); 

      if (completition == null) 
       throw new ArgumentNullException("completition"); 

      var cts = new CancellationTokenSource(); 
      var token = cts.Token; 

      var scheduler = TaskScheduler.FromCurrentSynchronizationContext(); 

      var task = new Task<TOut>(() => func(parameter), TaskCreationOptions.LongRunning); 
      task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler); 
      task.ContinueWith(asyncPart => 
      { 
       if (!token.IsCancellationRequested) 
        completition(asyncPart.Result, parameter); 
      }, 
           CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler); 
      task.Start(); 

      return cts; 
     } 

     public static CancellationTokenSource ExecuteBlockingOperation<TIn, TOut>(Func<TIn, TOut> func, TIn parameter, Action<TOut> completition, Action<AggregateException> onException) 
     { 
      if (func == null) 
       throw new ArgumentNullException("func"); 

      if (completition == null) 
       throw new ArgumentNullException("completition"); 

      var cts = new CancellationTokenSource(); 
      var token = cts.Token; 

      var scheduler = TaskScheduler.FromCurrentSynchronizationContext(); 

      var task = new Task<TOut>(() => func(parameter), TaskCreationOptions.LongRunning); 
      task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler); 
      task.ContinueWith(asyncPart => 
      { 
       if (!token.IsCancellationRequested) 
        completition(asyncPart.Result); 
      }, 
           CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler); 
      task.Start(); 

      return cts; 
     } 

     public static CancellationTokenSource ExecuteBlockingOperation<TIn, TOut>(Func<TIn, TOut> func, TIn parameter, Action completition, Action<AggregateException> onException) 
     { 
      if (func == null) 
       throw new ArgumentNullException("func"); 

      if (completition == null) 
       throw new ArgumentNullException("completition"); 

      var cts = new CancellationTokenSource(); 
      var token = cts.Token; 

      var scheduler = TaskScheduler.FromCurrentSynchronizationContext(); 

      var task = new Task<TOut>(() => func(parameter), TaskCreationOptions.LongRunning); 
      task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler); 
      task.ContinueWith(asyncPart => 
      { 
       if (!token.IsCancellationRequested) 
        completition(); 
      }, 
           CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler); 
      task.Start(); 

      return cts; 
     } 

     public static void ExecuteBlockingOperation(Action action, Action completition, Func<bool> shouldComplete, Action<AggregateException> onException) 
     { 
      if (action == null) 
       throw new ArgumentNullException("action"); 

      if (completition == null) 
       throw new ArgumentNullException("completition"); 

      var scheduler = TaskScheduler.FromCurrentSynchronizationContext(); 

      var task = new Task(action, TaskCreationOptions.LongRunning); 
      task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler); 
      task.ContinueWith(asyncPart => 
            { 
             if (shouldComplete == null || shouldComplete()) 
              completition(); 
            }, 
           CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler); 
      task.Start(); 
     } 

     public static void ExecuteBlockingOperation<TIn>(Action<TIn> action, TIn parameter, Action<TIn> completition, Predicate<TIn> shouldComplete, Action<AggregateException, TIn> onException) 
     { 
      if (action == null) 
       throw new ArgumentNullException("action"); 

      if (completition == null) 
       throw new ArgumentNullException("completition"); 

      var scheduler = TaskScheduler.FromCurrentSynchronizationContext(); 

      var task = new Task(() => action(parameter), TaskCreationOptions.LongRunning); 
      task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception, parameter), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler); 
      task.ContinueWith(asyncPart => 
            { 
             if (shouldComplete == null || shouldComplete(parameter)) 
              completition(parameter); 
            }, 
           CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler); 
      task.Start(); 
     } 

     public static void ExecuteBlockingOperation<TOut>(Func<TOut> func, Action<TOut> completition, Predicate<TOut> shoudComplete, Action<AggregateException> onException) 
     { 
      if (func == null) 
       throw new ArgumentNullException("func"); 

      if (completition == null) 
       throw new ArgumentNullException("completition"); 

      var scheduler = TaskScheduler.FromCurrentSynchronizationContext(); 

      var task = new Task<TOut>(func, TaskCreationOptions.LongRunning); 
      task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler); 
      task.ContinueWith(asyncPartTask => 
            { 
             if (shoudComplete == null || shoudComplete(asyncPartTask.Result)) 
              completition(asyncPartTask.Result); 
            }, 
           CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler); 
      task.Start(); 
     } 

     public static void ExecuteBlockingOperation<TIn, TOut>(Func<TIn, TOut> func, TIn parameter, Action<TOut, TIn> completition, Func<TOut, TIn, bool> shouldComplete, Action<AggregateException, TIn> onException) 
     { 
      if (func == null) 
       throw new ArgumentNullException("func"); 

      if (completition == null) 
       throw new ArgumentNullException("completition"); 

      var scheduler = TaskScheduler.FromCurrentSynchronizationContext(); 

      var task = new Task<TOut>(() => func(parameter), TaskCreationOptions.LongRunning); 
      task.ContinueWith(asyncPartTask => onException(asyncPartTask.Exception, parameter), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, scheduler); // on Exception 
      task.ContinueWith(asyncPart => 
            { 
             if (shouldComplete == null || shouldComplete(asyncPart.Result, parameter)) 
              completition(asyncPart.Result, parameter); 
            }, 
           CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, scheduler); 
      task.Start(); 
     }    
    }

出典

2012-11-07 10:55:16

asp.net C＃4.0で非同期メソッドを呼び出すにはどうすればよいですか？

答えて

関連する問題