C # Threading / Async: Exécuter une tâche en arrière-plan alors que l'interface utilisateur est interactif

Après avoir fait le tour sur les deux Async/Await et le Filetage, je suis toujours pas sûr de la bonne façon de l'appliquer à ma situation. Peu importe la variation que j'essaie de mon INTERFACE plane encore parce que je ne semble pas être l'appel de ma fonction de votre choix de manière asynchrone, en outre, je peut en effet avoir besoin d'enfiler pour ma solution.

Ce que je suis en train de faire: j'ai une application WPF sur lequel il y a un bouton que je voudrais démarrer une opération qui permet l'interaction avec le programme, par le biais de l'INTERFACE utilisateur ou autre. Une fois qu'une condition est remplie, qui est déterminée à l'extérieur de cette fonction, la fonction doit se terminer. Pour moi, cela semble assez standard, mais j'ai un sentiment que je ne suis malentendu quelque chose et j'ai mis en œuvre de façon incorrecte.

Ce que j'ai en ce moment:

private async void start_button_Click(object sender, RoutedEventArgs e)
{
    await StaticClass.MyFunction();
}

private void stop_button_Click(object sender, RoutedEventArgs e)
{
    StaticClass.stopFlag = true;
}

public static Task<int> myFunction()
{
    //Stuff Happens

    while(StaticClass.stopFlag == false)
        //Do Stuff

    //Stuff Happens

    return Task.FromResult(1) //I know this is bad, part of the reason I'm asking
}

J'espérais pour quelques conseils sur si j'aborde ce la bonne manière et de toute réflexion sur ce que je fais mal.

source d'informationauteur Karoly S

  1. 20

    Vous avez certainement mis en œuvre de façon incorrecte. Vous êtes de retour d'une Task<int>mais seulement une fois tout le travail qui a déjà été fait.

    Il me semble que vous devriez probablement juste un synchrone méthode:

    private static void MyFunction()
{
    //Loop in here
}

    Alors commencer une tâche, comme ceci:

    Task task = Task.Run((Action) MyFunction);

    Vous pouvez ensuite attendre que la tâche si vous voulez - bien que, dans l'exemple que vous avez donné, il n'y a aucun point à le faire, que vous n'avez pas à faire quoi que ce soit après la await de toute façon.

    Je serais aussi d'accord avec Reed que l'utilisation d'un CancellationToken serait plus propre que d'statique drapeau quelque part d'autre.

  2. 7

    Vous fait mal comprendre.

    public static Task<int> myFunction()
{
    //Stuff Happens

    while(StaticClass.stopFlag == false)
        //Do Stuff

    //Stuff Happens

    return Task.FromResult(1) //I know this is bad, part of the reason I'm asking
}

    Tous que le code qui se passe encore dans le intial await StaticClass.MyFunction(); appel, il ne revient jamais le contrôle à l'appelant. Ce que vous devez faire est de mettre la boucle de la partie dans un thread séparé.

    public static async Task myFunction()
{
    //Stuff Happens on the original UI thread

    await Task.Run(() => //This code runs on a new thread, control is returned to the caller on the UI thread.
    {
        while(StaticClass.stopFlag == false)
            //Do Stuff
    });

    //Stuff Happens on the original UI thread after the loop exits.
}
  3. 3

    Au lieu d'essayer d'utiliser un bool pour cela, vous devez envisager d'utiliser la géré annulation cadre intégré dans le cadre.

    Fondamentalement, vous feriez construire un CancellationTokenSourceet passer un CancellationToken pour votre méthode qui pourrait être utilisée pour manipuler l'annulation.

    Enfin, votre méthode actuelle ne sera jamais sortir de la thread de l'INTERFACE utilisateur. Vous auriez besoin d'utiliser Task.Run ou similaire pour déplacer la méthode pour le pool de threads si vous ne voulez pas bloquer l'INTERFACE utilisateur.

  4. 1

    Comme alternative, vous pouvez regarder dans l'aide de BackgroundWorker classe pour faire le travail, votre INTERFACE utilisateur séjour interactive.