C# -Quatre Modèles en mode d'exécution Asynchrone

J'ai entendu dire qu'il y a quatre modèles en mode d'exécution asynchrone.

Il y a quatre modèles dans async déléguer l'exécution: le sondage, en Attente d'Achèvement, Notification de fin de, et de "Fire and Forget"

Quand j'ai le code suivant :

class AsynchronousDemo
{
    public static int numberofFeets = 0;
    public delegate long StatisticalData();

    static void Main()
    {
        StatisticalData data = ClimbSmallHill;
        IAsyncResult ar = data.BeginInvoke(null, null);
        while (!ar.IsCompleted)
        {
            Console.WriteLine("...Climbing yet to be completed.....");
            Thread.Sleep(200);

        }
        Console.WriteLine("..Climbing is completed...");
        Console.WriteLine("... Time Taken for  climbing ....{0}", 
        data.EndInvoke(ar).ToString()+"..Seconds");
        Console.ReadKey(true);

    }


    static long ClimbSmallHill()
    {
        var sw = Stopwatch.StartNew();
        while (numberofFeets <= 10000)
        {
            numberofFeets = numberofFeets + 100;
            Thread.Sleep(10);
        }
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }
}

1) Quel est le motif le code ci-dessus mis en œuvre ?

2) Pouvez-vous expliquer le code ,comment puis-je mettre en place le reste ..?

InformationsquelleAutor user215675 | 2009-11-23

asynchronous c#execution

93

Ce que vous avez là est le motif d'Interrogation. Dans ce modèle vous poser continuellement des "Sommes-nous encore là?" Le while boucle est en train de faire le blocage. Le Thread.Sleep empêche le processus de manger des cycles de PROCESSEUR.

Attendre la fin est le "je t'appelle" approche.
```
IAsyncResult ar = data.BeginInvoke(null, null);
//wait until processing is done with WaitOne
//you can do other actions before this if needed
ar.AsyncWaitHandle.WaitOne(); 
Console.WriteLine("..Climbing is completed...");
```
Donc dès que WaitOne est appelé bloquant jusqu'à ce que l'escalade est terminée. Vous pouvez effectuer d'autres tâches avant de les bloquer.

Avec Notification de fin de vous en disant: "Vous m'appelez, je ne vais pas vous appeler."
```
IAsyncResult ar = data.BeginInvoke(Callback, null);

//Automatically gets called after climbing is complete because we specified this
//in the call to BeginInvoke
public static void Callback(IAsyncResult result) {
    Console.WriteLine("..Climbing is completed...");
}
```
Il n'y a pas de blocage ici, car Callback va être notifié.

Et le feu et oublier serait
```
data.BeginInvoke(null, null);
//don't care about result
```
Il n'y a également aucun blocage ici, parce que vous n'avez pas de soins lors de l'escalade est fini. Comme son nom l'indique, vous oublier. Vous dites: "Ne m'appelez pas, je ne vais pas vous appeler, mais encore, ne m'appelez pas."
- +1 me Battre pour elle.
- Si cela ne vous dérange pas pouvez vous s'il vous plaît de comparer ces modèles en termes de consommation de temps?
- Que voulez-vous dire en termes de consommation de temps?
- Laquelle de ces modèle de blocs d'autres threads..?
- J'ai mis à jour ma réponse. Juste pour être clair, rien ne va bloquer les autres threads. Le seul fil qui sera bloqué est celui qui veut un résultat (qui est aussi celui qui a commencé à la demande).
- Super réponse, une seule petite chose, c'est que (en fonction des questions à propos de EndInvoke sur), vous êtes censé pour toujours appeler EndInvoke. Bien sûr, cela supprime complètement le point d'être asynchrone si vous avez toujours à bloc, en particulier avec le Feu et oublier modèle.
- Ne m'appelez pas, je ne vais pas vous appeler, mais encore, ne m'appelez pas (ce n'est pas vous, c'est moi. Je pense que nous devrions commencer à voir les autres Threads)
- En 2ème approche Attendre la fin, comment est WaitOne() en faisant des "je t'appelle"? est-il en faisant un lent d'interrogation à l'interne?
InformationsquelleAutor Bob

while (!ar.IsCompleted)
{
    Console.WriteLine("...Climbing yet to be completed.....");
    Thread.Sleep(200);
}

C'est classique d'interrogation. - Vérifier, le sommeil, vérifier de nouveau,

InformationsquelleAutor Chris Cudmore

Ce code est d'Interrogation:

while (!ar.IsCompleted)

C'est la clé, vous gardez le contrôle si oui ou non c'est terminé.

Ce code n'est pas vraiment favorable à tous les quatre, mais un peu de code n'.

Process fileProcess = new Process();
//Fill the start info
bool started = fileProcess.Start();

Le "Début" de la méthode est Asynchrone. Il donne naissance à un nouveau processus.

Nous pourrions faire de chacun des moyens que vous demande avec ce code:

//Fire and forget
//We don't do anything, because we've started the process, and we don't care about it

//Completion Notification
fileProcess.Exited += new EventHandler(fileProcess_Exited);

//Polling
while (fileProcess.HasExited)
{

}

//Wait for completion
fileProcess.WaitForExit();

InformationsquelleAutor McKay

Vous devez vous connecter pour publier un commentaire.