Quel est le nouveau C# attendent fonctionnalité?

Quelqu'un peut-il expliquer ce qu'est l' await fonction n'?

Est-ce cela que vous faites référence? la Programmation Asynchrone en C# 5.0 partie deux: d'Où l'attendent?
Voir aussi la Programmation Asynchrone avec Async et Await
Nice exemples aussi dans le dotnetperls.com/async.
Je ne crois pas que cette question est trop vaste ou devrait être fermé. Elle demande ce qu'un mot clé. (C'était une version antérieure différent?)

InformationsquelleAutor Chris Nicol | 2010-10-30

61

Ils ont juste parlé au PDC hier!

Attendent est utilisé en conjonction avec des Tâches de programmation parallèle) dans .NET. C'est un mot-clé étant introduite dans la prochaine version de .NET. Il est plus ou moins permet de "suspendre" l'exécution d'une méthode permettant d'attendre la Tâche à achever l'exécution. Voici un bref exemple:
```
//create and run a new task  
Task<DataTable> dataTask = new Task<DataTable>(SomeCrazyDatabaseOperation);

//run some other code immediately after this task is started and running  
ShowLoaderControl();  
StartStoryboard();

//this will actually "pause" the code execution until the task completes.  It doesn't lock the thread, but rather waits for the result, similar to an async callback  
//please so also note, that the task needs to be started before it can be awaited. Otherwise it will never return
dataTask.Start();
DataTable table = await dataTask;

//Now we can perform operations on the Task result, as if we're executing code after the async operation completed  
listBoxControl.DataContext = table;  
StopStoryboard();  
HideLoaderControl();
```
- Quand est-il du C# sous forme de promesses: en.wikipedia.org/wiki/Futures_and_promises
- Cela ressemble beaucoup au Fil.Join().
- Me rappelle de COMEFROM
- Pour l'amour de souci d'exhaustivité, nous allons ajouter que le ci-dessus morceau de code doit être enveloppé dans une méthode qui est orné avec un mot-clé async. Cette méthode doit retourner immédiatement dès que le premier mot clé await est rencontrés celle-ci.
- Également intéressant de mentionner que, dans le corps du code écrit APRÈS le 'attendre' mot-clé est réécrit par le compilateur pour former la méthode de rappel. De manière synchrone style de codage avec les avantages de l'exécution asynchrone.
- Dans vos paroles: il vous permet de "mettre en pause" la méthode, mais il convient de noter qu'il n'a pas de pause ou de bloquer le fil.
- Je pense que l'on fait trop de cette distinction. t bloc conceptuel fil de l'excecution, et que peut correspond à l'un des OS du thread, mais les détails dépendent de l'ordonnanceur. C'est vraiment un thread juste pas le système d'exploitation fil. Ce n'est pas sans intérêt, mais en termes de compréhension de flux de programme (et ce sont des constructions de flux de contrôle), il n'est pas important.
- Quelle est la différence à l'aide d'un WaitHandle et ensuite appeler WaitAll() ou WaitAny()?
- Cette réponse est trompeuse. await ne fait pas une pause quoi que ce soit, il s'enroule le repos ou la méthode de la poursuite de la tâche si Task attendue est toujours en cours d'exécution.
- "De plus ou de moins vous permet de "suspendre" l'exécution d'une méthode permettant d'attendre la Tâche à achever l'exécution". ATTENDRE. Vous voulez dire - attendent MyFunctionAsync() est LA MÊME que juste MyFunction() ? attendent tue async, MyFunction() le reste. WTF devons-nous attendre async pour ?
- D'abord ils font Async fonctions, puis, ils forment "en attente" de l'opérateur (ou de ce qu'il est) pour faire que Async fonction normale de la fonction synchrone :)))
- Cet exemple n'est pas de démontrer la puissance de l'attendent utilisé à la Tâche. Il commence une Tâche, et immédiatement, attendez qu'elle se termine. Nous devons ajouter quelque chose entre la Tâche.start() et attendre.
InformationsquelleAutor RTigger
47

Fondamentalement, la async et await mots-clés vous permettent de spécifier que l'exécution d'une méthode doit s'arrêter à tous les usages de await, qui marque asynchrone appels de méthode, et de reprendre ensuite une fois l'opération asynchrone est terminée. Cela vous permet d'appeler une méthode dans une application thread principal et la poignée complexe de travailler de manière asynchrone, sans la nécessité de définir de manière explicite les threads et les jointures ou de blocage de l'application du thread principal.

Pensez à cela comme quelque peu semblable à une yield return déclaration d'une méthode de production d'un IEnumerable. Lorsque le moteur d'exécution frappe le yield, il va enregistrer la méthode de l'état actuel, et de renvoyer la valeur de référence ou être donné. La prochaine fois IEnumerator.MoveNext() est appelée sur l'objet de retour (qui est généré en interne par le moteur d'exécution), la méthode de l'ancienne restauration de l'état de la pile et l'exécution se poursuit à la ligne suivante après la yield return comme si nous n'avions jamais quitté la méthode. Sans ce mot-clé, un IEnumerator type doit être personnalisés pour stocker et gérer l'itération des demandes, avec des méthodes qui peuvent devenir TRÈS complexe en effet.

De même, une méthode marquée comme async doit avoir au moins un await. Sur un await, le runtime enregistrer le thread courant de l'état et de la pile d'appel, faire l'appel asynchrone, et détendez-vous en arrière pour l'exécution de la boucle de message pour gérer le message suivant et garder l'application réactive. Lors de l'opération asynchrone est terminée, lors de la prochaine planification occasion, la pile d'appel de l'opération asynchrone est poussé en arrière et a continué comme si l'appel est synchrone.

Donc, ces deux nouveaux mots-clés essentiellement de simplifier le codage des processus asynchrones, comme yield return simplifié de la génération de la coutume enumerables. Avec un couple de mots-clés et un peu de connaissances de base, vous pouvez ignorer tout ce qui prête à confusion et souvent sujette à des erreurs, des détails traditionnels du modèle asynchrone. Ce sera d'une aide INESTIMABLE dans pratiquement n'importe quel event-driven " GUI application comme Winforms, WPF de Silverlight.

InformationsquelleAutor KeithS
31

Actuellement accepté réponse est trompeuse.
await n'est pas mise en pause de quoi que ce soit.
Tout d'abord, il peut être utilisé seulement dans les méthodes ou les lambdas marqué comme async et le retour Task ou void si vous ne vous souciez pas d'avoir Task instance en cours d'exécution dans cette méthode.

Voici une illustration:
```
internal class Program
{
    private static void Main(string[] args)
    {
        var task = DoWork();
        Console.WriteLine("Task status: " + task.Status);
        Console.WriteLine("Waiting for ENTER");
        Console.ReadLine();
    }

    private static async Task DoWork()
    {
        Console.WriteLine("Entered DoWork(). Sleeping 3");
        //imitating time consuming code
        //in a real-world app this should be inside task, 
        //so method returns fast
        Thread.Sleep(3000);

        await Task.Run(() =>
            {
                for (int i = 0; i < 10; i++)
                {
                    Console.WriteLine("async task iteration " + i);
                    //imitating time consuming code
                    Thread.Sleep(1000);
                }
            });

        Console.WriteLine("Exiting DoWork()");
    }
}
```
De sortie:

Entré DoWork(). Couchage 3

async task itération 0

Le statut de la tâche: WaitingForActivation

D'attente pour ENTRER

async task itération 1

async task itération 2

async task itération 3

async task itération 4

async task itération 5

async task itération 6

async task itération 7

async task itération 8

async task itération 9

La Sortie De DoWork()
- Vous avez raison await n'arrête pas de rien, mais il est logique de penser qu'il n'. La accepté de répondre a une pause entre guillemets, ce qui implique qu'il n'est pas vrai, c'est juste une façon de penser sur ce qui se passe. Je dirais que c'est pas vraiment un problème, mais ce n'est certainement pas bien expliqué. Comme pour ne pas être dans une méthode marquée async, au moment que le post a été écrit à la fonction n'avait pas encore été publié, et la syntaxe pour qu'il ne l'avait même pas encore été inventé. Expliquant la syntaxe maintenant qu'il a est très bien, il suffit de comprendre pourquoi il n'est pas dans cette réponse.
- À cette réponse, pourquoi êtes-vous à l'aide de Thread.Sleep dans votre tâche asynchrone? Vous ne devriez vraiment pas être à l'aide d'une méthode de blocage comme ça. Il devrait être remplacé par await Task.Delay(X000); au lieu de cela, sauf si vous essayez de démontrer quelque chose en les incluant, dans ce cas, veuillez expliquer ce que vous essayez de montrer en mélangeant asynchrone et non des opérations asynchrones dans la méthode.
- 1. ok, fait sens
- 2. juste imiter temps de code pour illustrer l'ordre d'exécution
- Si c'est ce que votre intention est ensuite, vous devez ajouter un commentaire à côté de chaque Sleep pour indiquer que, quelque chose comme "espace réservé pour de vrai travail" ou quelque chose comme ça. Aussi, si vous avez des CPU, des travaux qui seront exécutés pendant 3 secondes (la première de sommeil), il ne devrait pas être dans le contexte actuel, il devrait être à l'intérieur d'un await Task.Run(... comme l'exemple suivant.
- bien sûr, il est à l'extérieur, par l'intention, afin que nous puissions voir l'ordre d'exécution
- Vous êtes également conscient qu'il va bloquer l'appelant pendant 3 secondes avant même qu'elle leur donne la tâche qu'ils peuvent await sur? De sens que si cela est appelé à partir d'un thread d'INTERFACE utilisateur il permet de bloquer le thread d'INTERFACE utilisateur pour 3 secondes? L'idée de ce modèle est d'éviter de faire des choses comme ça.
- oui, qui était le point. Afin de montrer toutes les étapes de l'exécution. Ce n'est pas un exemple réel.
- Si vous allez à démontrer des choses que vous ne devriez pas le faire c'est mieux de l'état qu'ils ne devraient pas faire et pourquoi. Comme il est, les lecteurs de votre réponse pourrait penser que c'est un code vaut imitant dans l'esprit.
- êtes-vous à la traîne moi?
- Nope. Je suis en train de vous aider à améliorer votre réponse.
- fait de. Je vous remercie.
- Anri ...j'apprécie vraiment vos efforts ici. Merci beaucoup!!
- Quand il y a un type de retour Task, appelant attend la méthode asynchrone de ne pas bloquer. Donc, un Thread.Sleep() comme l'action dans une méthode asynchrone est en fait juste une mauvaise conception. Si vous avez une méthode asynchrone, vous devez vous assurer qu'il est en fait asynchrone. C'est la main Task à l'appelant sans blocage.
InformationsquelleAutor Anri
10

Pour quelqu'un de nouveau à la programmation asynchrone en .NET, voici un (totalement faux) analogie dans le cas, vous êtes peut-être plus familiers avec les appels AJAX à l'aide de JavaScript/jQuery. Un simple jQuery AJAX post ressemble à ceci:
```
$.post(url, values, function(data) {
  //AJAX call completed, do something with returned data here
});
```
La raison pour laquelle nous traiter les résultats dans une fonction de rappel est afin de ne pas bloquer le thread courant en attendant l'appel AJAX de retour. Seulement quand la réponse est prêt va le rappel de me faire virer, de libérer le thread en cours pour faire d'autres choses dans le temps de le dire.

Maintenant, si JavaScript soutenu la await mot-clé (qui, bien sûr, il n'a pas (encore!)), vous pouvez obtenir la même chose avec cela:
```
var data = await $.post(url, values);
//AJAX call completed, do something with returned data here
```
C'est beaucoup plus clair, mais il semble vraiment comme nous avons introduit synchrone, le blocage de code. Mais le (faux) compilateur JavaScript aurait tout pris après await et câblé dans un rappel, donc, au moment de l'exécution le deuxième exemple, se comportent exactement comme la première.

Il peut ne pas sembler comme il vous sauver beaucoup de travail, mais quand il s'agit de choses comme la gestion des exceptions et la synchronisation des contextes, le compilateur est en train de faire une beaucoup de levage lourd pour vous. Pour en savoir plus, je vous recommande la Faq suivie par Stephen Cleary le blog de la série.
- Coller avec cette fausse analogie (qui m'a beaucoup aidé btw, merci!), que voulez-vous dire "tout ce qui est après"? Tout ce qui relève de la même fonction (méthode) seulement? Ou tout ce qui est après elle que dans quoi que ce soit qui pourrait avoir été ajouté à la pile d'appel?
- "Tout ce qui est après" = le reste de la méthode. Le compilateur fait re-écrit le reste de la méthode de rappel et de contrôle renvoie immédiatement à la méthode actuelle de l'appelant.
- Brillant Todd, merci encore pour ton explication. Utile pour les autres aussi j'en suis sûr.
InformationsquelleAutor Todd Menier

-2

Si j'avais à le mettre en œuvre en Java, il ressemblerait à quelque chose comme ceci:

/**
 * @author Ilya Gazman
 */
public abstract class SynchronizedTask{

    private ArrayList<Runnable> listeners = new ArrayList<Runnable>();

    private static final ThreadPoolExecutor threadPoolExecutor =  new ThreadPoolExecutor(6, 6, 0, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1000));

    public final void await(Runnable listener){
        synchronized (this) {
            listeners.add(listener);
        }
    }

    public void excecute(){
        onExcecute();
        for (int i = listeners.size() - 1; i >= 0; i--) {
            Runnable runnable;
            synchronized (this) {
                runnable = listeners.remove(i);
            }
            threadPoolExecutor.execute(runnable);
        }
    }

    protected abstract void onExcecute();
}

Votre application utilise comme ceci:

public class Test{
    private Job job = new Job();

    public Test() {
        craeteSomeJobToRunInBackground();
        methode1();
        methode2();
    }

    private void methode1(){
        System.out.println("Running methode 1");
        job.await(new Runnable() {

            @Override
            public void run() {
                System.out.println("Continue to running methode 1");
            }
        });
    }

    private void methode2(){
        System.out.println("Running methode 2");
    }

    private void craeteSomeJobToRunInBackground() {
        new Thread(new Runnable() {

            @Override
            public void run() {
                job.excecute();
            }
        }).start();
    }

    private class Job extends SynchronizedTask{

        @Override
        protected void onExcecute() {
            try {
                Thread.sleep(1000);
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Job is done");
        }
    }
}

InformationsquelleAutor Ilya Gazman

Vous devez vous connecter pour publier un commentaire.