Explication détaillée de l'utilisation de async et wait en C#

Cet article présente principalement l'utilisation spécifique de async et wait en C#. L'éditeur pense que c'est plutôt bien, je vais donc le partager avec vous maintenant et le donner comme référence. Suivons l'éditeur et jetons un coup d'œil.

Async et wait ont été introduits en C# 5.0. Ces deux mots-clés facilitent l’écriture de code asynchrone.

Regardez un exemple :

public class MyClass 
{ 
  public MyClass() 
  { 
    DisplayValue(); //这里不会阻塞 
    System.Diagnostics.Debug.WriteLine("MyClass() End."); 
  } 
  public Task<double> GetValueAsync(double num1, double num2) 
  { 
    return Task.Run(() => 
    { 
      for (int i = 0; i < 1000000; i++) 
      { 
        num1 = num1 / num2; 
      } 
      return num1; 
    }); 
  } 
  public async void DisplayValue() 
  { 
    double result = await GetValueAsync(1234.5, 1.01);//此处会开新线程处理GetValueAsync任务，然后方法马上返回 
    //这之后的所有代码都会被封装成委托，在GetValueAsync任务完成时调用 
    System.Diagnostics.Debug.WriteLine("Value is : " + result); 
  } 
}

Ce qui précède appelle la méthode asynchrone DisplayValue() marquée avec le mot-clé async dans le constructeur de MyClass , la méthode DisplayValue() exécute une tâche asynchrone GetValueAsync() marquée avec le mot clé wait. Cette tâche asynchrone doit utiliser Task ou Task est terminé. Le type est void ou TResult. Tout le code après wait GetValueAsync() dans la méthode DisplayValue() sera exécuté lorsque la tâche asynchrone est terminée.

Le code réellement exécuté par la méthode DisplayValue() est le suivant :

public void DisplayValue() 
{ 
  System.Runtime.CompilerServices.TaskAwaiter<double> awaiter = GetValueAsync(1234.5, 1.01).GetAwaiter(); 
  awaiter.OnCompleted(() => 
    { 
      double result = awaiter.GetResult(); 
      System.Diagnostics.Debug.WriteLine("Value is : " + result); 
    }); 
}

Comme vous pouvez le constater, les fonctions async et wait les mots-clés remplacent simplement ce qui précède. Le code devient simplement plus simple et plus facile à comprendre.

La sortie du programme est la suivante :

MyClass() End.
La valeur est : 2.47032822920623E-322

Ce qui suit en est une que j'ai écrite. Les classes statiques peuvent faciliter les appels asynchrones d'une fonction commune :

public static class TaskAsyncHelper 
{ 
  /// <summary> 
  /// 将一个方法function异步运行，在执行完毕时执行回调callback 
  /// </summary> 
  /// <param name="function">异步方法，该方法没有参数，返回类型必须是void</param> 
  /// <param name="callback">异步方法执行完毕时执行的回调方法，该方法没有参数，返回类型必须是void</param> 
  public static async void RunAsync(Action function, Action callback) 
  { 
    Func<System.Threading.Tasks.Task> taskFunc = () => 
    { 
      return System.Threading.Tasks.Task.Run(() => 
      { 
        function(); 
      }); 
    }; 
    await taskFunc(); 
    if (callback != null) 
      callback(); 
  } 
 
  /// <summary> 
  /// 将一个方法function异步运行，在执行完毕时执行回调callback 
  /// </summary> 
  /// <typeparam name="TResult">异步方法的返回类型</typeparam> 
  /// <param name="function">异步方法，该方法没有参数，返回类型必须是TResult</param> 
  /// <param name="callback">异步方法执行完毕时执行的回调方法，该方法参数为TResult，返回类型必须是void</param> 
  public static async void RunAsync<TResult>(Func<TResult> function, Action<TResult> callback) 
  { 
    Func<System.Threading.Tasks.Task<TResult>> taskFunc = ()=> 
      { 
        return System.Threading.Tasks.Task.Run(()=> 
          { 
            return function(); 
          }); 
      }; 
    TResult rlt = await taskFunc(); 
    if(callback != null) 
      callback(rlt); 
  } 
}

C'est très simple à utiliser. Il suffit de passer le nom de la méthode en paramètre. le plus couramment utilisé est la fonction de sérialisation fastidieuse qui est transmise pour éviter de bloquer le processus d'interface utilisateur, provoquant un décalage et affectant l'expérience utilisateur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!