मैं asp.net C# 4.0 में async विधियों को कैसे कॉल करूं?

Question

मुझे पता है कि .NET 4.5 के साथ प्रतीक्षा है, async कीवर्ड जो एसिंक विधियों की आसान कॉलिंग की अनुमति देता है। मैं वर्तमान में अध्ययन कर रहा हूं कि सी # 4.0 में एसिंक कॉल कैसे करें। एक उदाहरण मैं एक एसिंक कॉल करना चाहता हूं जहां डेटाग्रिड डेटाबेस हो रहा है।

यदि आप मुझे कुछ लिंक प्रदान कर सकते हैं तो मैं वास्तव में इसकी सराहना करता हूं।

Answer 1

कार्य का उपयोग करने पर एक नज़र डालें, यह .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

Answer 2

उपयोग Task.ContinueWith जो मूल रूप से अपनी कार्रवाई को निष्पादित करता है एक बार काम पूरा करता है।

कुछ उदाहरण जो उपयोगी हो सकता है:

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

Answer 3

हम async संचालन को क्रियान्वित करने के लिए कुछ उपकरण वर्ग बनाया है।

ये विधियां वास्तव में क्या करती हैं: कार्रवाई को असीमित रूप से निष्पादित करें और फिर सिंक्रनाइज़ेशन संदर्भ के अनुसार पूर्णता के निष्पादन को पोस्ट करें।

हमने इसे टीपीएल के आवरण के रूप में आसानी से उपयोग करने के लिए बनाया है जब हम लंबे समय तक चल रहे संचालन को कॉल करते हैं। इस वर्ग में उन कार्रवाइयों के अनुरूप भी हैं जिन्हें रद्द किया जा सकता है, न केवल त्याग दिया जाता है।

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(); 
     }    
    }