Quelle est l'utilisation de Task.FromResult <TResult> en C #

En C # et TPL ( Task Parallel Library ), la Taskclasse représente un travail en cours qui produit une valeur de type T.

J'aimerais savoir quel est le besoin de la méthode Task.FromResult ?

Autrement dit: dans un scénario où vous avez déjà la valeur produite sous la main, quel est le besoin de la réintégrer dans une tâche?

La seule chose qui me vient à l'esprit est qu'il est utilisé comme adaptateur pour d'autres méthodes acceptant une instance de Task.

J'ai trouvé deux cas d'utilisation courants:

1. Lorsque vous implémentez une interface qui autorise les appelants asynchrones, mais que votre implémentation est synchrone.
2. Lorsque vous stubbing / mocking code asynchrone pour le test.

Un exemple serait une méthode qui utilise un cache. Si le résultat est déjà calculé, vous pouvez renvoyer une tâche terminée avec la valeur (en utilisant Task.FromResult). Si ce n'est pas le cas, continuez et retournez une tâche représentant un travail en cours.

Exemple de cache: exemple de cache utilisant Task.FromResult pour les valeurs pré-calculées

Utilisez-le lorsque vous souhaitez créer une méthode en attente sans utiliser le mot clé async. J'ai trouvé cet exemple:

public class TextResult : IHttpActionResult
{
    string _value;
    HttpRequestMessage _request;

    public TextResult(string value, HttpRequestMessage request)
    {
        _value = value;
        _request = request;
    }
    public Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
    {
        var response = new HttpResponseMessage()
        {
            Content = new StringContent(_value),
            RequestMessage = _request
        };
        return Task.FromResult(response);
    }
}

Ici, vous créez votre propre implémentation de l'interface IHttpActionResult à utiliser dans une action Web Api. La méthode ExecuteAsync est censée être asynchrone, mais vous n'avez pas besoin d'utiliser le mot clé async pour la rendre asynchrone et attendue. Puisque vous avez déjà le résultat et que vous n'avez rien à attendre, il est préférable d'utiliser Task.FromResult.

Depuis MSDN:

Cette méthode est utile lorsque vous effectuez une opération asynchrone qui renvoie un objet Task et que le résultat de cet objet Task est déjà calculé.

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

Utilisez le Task.FromResult lorsque vous souhaitez avoir une opération asynchrone mais que parfois le résultat est en cours de manière synchrone. Vous pouvez trouver un bon exemple ici http://msdn.microsoft.com/en-us/library/hh228607.aspx .

Je dirais que vous pouvez utiliser Task.FromResult pour des méthodes synchrones qui prennent beaucoup de temps à se terminer alors que vous pouvez effectuer d'autres travaux indépendants dans votre code. Id plutôt faire ces méthodes pour appeler async. Mais imaginez la situation où vous n'avez aucun contrôle sur le code appelé et que vous voulez ce traitement parallèle implicite.