Comment faire un Asynchrone de la Méthode renvoie une valeur?

Je sais comment faire des méthodes Asynchrones, mais dire que j'ai une méthode qui est beaucoup de travail, puis renvoie une valeur booléenne?

Comment puis-je retourner une valeur booléenne sur le rappel?

Clarification:

public bool Foo(){
    Thread.Sleep(100000); //Do work
    return true;
}

Je veux être en mesure de faire ce asynchrone.

InformationsquelleAutor Overload119 | 2011-05-18
  1. 53

    Il ya quelques façons de le faire... le plus simple est d'avoir la méthode async également faire le suivi de l'opération. Une autre approche est de passer dans un rappel, c'est à dire

    void RunFooAsync(..., Action<bool> callback) {
     //do some stuff
     bool result = ...

     if(callback != null) callback(result);
}

    Une autre approche serait d'élever un événement (avec le résultat dans le cas des arguments de données) lorsque l'opération asynchrone est terminée.

    Aussi, si vous utilisez le TPL, vous pouvez utiliser ContinueWith:

    Task<bool> outerTask = ...;
outerTask.ContinueWith(task =>
{
    bool result = task.Result;
    //do something with that
});
    • Belle exemple simple de rappel approche
    InformationsquelleAutor Marc Gravell
  2. 115

    De C# 5.0, vous pouvez spécifier la méthode 

    public async Task<bool> doAsyncOperation()
{
    //do work
    return true;
}

bool result = await doAsyncOperation();
    • Pour quelqu'un qui se soucie, pour obtenir les résultats que vous souhaitez utiliser bool result = await doAsyncOperation();
    • Chaque fois que vous allez utiliser le "en attente de" mot-clé, il doit être à l'intérieur d'une méthode qui a été marqué avec, au minimum, "async". J'ai d'abord que seul le travailleur méthode a dû être marqué de cette façon. Par exemple, même si votre appelant la méthode ne retourne rien, vous avez le nom "async void MyCallerMethod"
    • Ouais mais agaçants avertissement que la méthode sera exécutée de façon synchrone
    • attendent Tâche.FromResult(true) doit rejeter cette mise en garde.
    • Cela ne va pas faire quoi que ce soit de manière asynchrone, à moins que vous await quelque chose dans le corps de la méthode. De retour Task.FromResult(true) ne change pas. Le corps de la méthode s'exécute de façon synchrone sur l'appelant fil jusqu'à ce que les premiers attendent.
    • Me semble que pour que cela fonctionne, le "bool result = ..." ligne dispose également d'être à l'intérieur d'une méthode asynchrone, donc je ne pense pas que cela répond vraiment à la question
    • Oui, l'appelant doit également être asynchrone pour que cela fonctionne. Et, chaque appelant au-dessus de ce point également. Vous pouvez éviter cela en utilisant Task.FromResult directement, plutôt que d'utiliser await. Cependant, comme Drew l'a noté plus tôt, cela fonctionne de façon synchrone sur le thread appelant.

    InformationsquelleAutor Dave Arkell
  3. 4

    Probablement la façon la plus simple de le faire est de créer un délégué et ensuite BeginInvoke, suivi d'une attente à un certain moment dans l'avenir, et un EndInvoke.

    public bool Foo(){
    Thread.Sleep(100000); //Do work
    return true;
}

public SomeMethod()
{
    var fooCaller = new Func<bool>(Foo);
    //Call the method asynchronously
    var asyncResult = fooCaller.BeginInvoke(null, null);

    //Potentially do other work while the asynchronous method is executing.

    //Finally, wait for result
    asyncResult.AsyncWaitHandle.WaitOne();
    bool fooResult = fooCaller.EndInvoke(asyncResult);

    Console.WriteLine("Foo returned {0}", fooResult);
}
    • Le AsyncWaitHandle est un WaitHandle. Il n'a pas un WaitOne() la méthode. Vous devez le jeter vers le bas tout ce qu'il tient pour attendre la fin.
    • Vous voudrez peut-être jeter un oeil à cet exemple: msdn.microsoft.com/en-us/library/.... Jetez aussi un oeil à la documentation de l' WaitHandle.WaitOne méthode: msdn.microsoft.com/en-us/library/58195swd.aspx
    • Ou vous pouvez simplement coller ce code dans un programme C# et de le tester. Il semblait fonctionner pour moi.
    • Désolé, j'ai confondu avec le jeu...
    InformationsquelleAutor Jim Mischel
  4. 3

    Utiliser un BackgroundWorker. Il vous permettra d'obtenir des rappels sur l'achèvement et vous permettent de suivre les progrès. Vous pouvez définir la valeur de Résultat sur les arguments de l'événement à la valeur qui en résulte.

        public void UseBackgroundWorker()
    {
        var worker = new BackgroundWorker();
        worker.DoWork += DoWork;
        worker.RunWorkerCompleted += WorkDone;
        worker.RunWorkerAsync("input");
    }

    public void DoWork(object sender, DoWorkEventArgs e)
    {
        e.Result = e.Argument.Equals("input");
        Thread.Sleep(1000);
    }

    public void WorkDone(object sender, RunWorkerCompletedEventArgs e)
    {
        var result = (bool) e.Result;
    }
    • Un arrière-plan travailleur est contre-productive, ici. Ne savez-vous pas AutoResetEvent/ManualResetEvent?
    • Je suis en désaccord avec cela, un BackgroundWorker et la RunWorkerCompleted événement sont une très bonne approche ici
    • non je n'ai pas. Je vais voir ce que je peux apprendre à ce sujet. Mais si vous pourriez nous expliquer pourquoi vous pensez que c'est contre-productive, je voudrais comprendre.
    • C'est contre-productif puisque vous êtes le codage trop pour quelque chose qui n'a pas vraiment besoin de ce genre de code. Un arrière-plan travailleur est ce que vous faites quand vous avez un long processus en cours d'exécution que les rapports à l'INTERFACE utilisateur. Une méthode asynchrone en c# n'a pas besoin de rapport de progrès, seule fin car les autres peuvent attendre son achèvement (c'est ce que Auto/MenualResetEvent sont pour). La méthode async modèle est un idiome de manière asynchrone pour l'invocation d'une méthode. Le seul des approches valables voici ce que j'ai proposé ou qu' @Marc suggéré.
    • Pas chaque chose est un vernis à ongles. Il peut fonctionner. Il est sémantiquement incorrect.
    InformationsquelleAutor NerdFury
  5. 1

    Peut-être vous pouvez essayer de BeginInvoke un délégué pointant vers votre méthode comme suit:

    

    delegate string SynchOperation(string value);

    class Program
    {
        static void Main(string[] args)
        {
            BeginTheSynchronousOperation(CallbackOperation, "my value");
            Console.ReadLine();
        }

        static void BeginTheSynchronousOperation(AsyncCallback callback, string value)
        {
            SynchOperation op = new SynchOperation(SynchronousOperation);
            op.BeginInvoke(value, callback, op);
        }

        static string SynchronousOperation(string value)
        {
            Thread.Sleep(10000);
            return value;
        }

        static void CallbackOperation(IAsyncResult result)
        {
            //get your delegate
            var ar = result.AsyncState as SynchOperation;
            //end invoke and get value
            var returned = ar.EndInvoke(result);

            Console.WriteLine(returned);
        }
    }

    Ensuite utiliser la valeur de la méthode que vous avez envoyé comme AsyncCallback pour continuer..

    InformationsquelleAutor Omer Ben
  6. -2

    Vous devez utiliser le EndXXX de votre méthode async pour retourner la valeur. EndXXX doit attendre jusqu'à ce qu'il y a un résultat à l'aide de la IAsyncResult de WaitHandle et que le retour à la valeur.

    InformationsquelleAutor the_drow