La compréhension du contexte en C# 5 async/await

Suis-je correct que async/await lui-même n'a rien à faire avec la concurrence d'accès/parallélisme et n'est rien de plus que la continuation passing style (CPS) de la mise en œuvre? Et le réel, le filetage est réalisé par SynchronizationContext instance await passe/restaure?

Si c'est correct, j'ai la question suivante sur SynchronizationContext:

il garantit qu'une suite sera exécuté sur le même thread.

Cependant, il y a aucune garantie que le contexte du thread de l'information est conservée? Je veux dire Name, CurrentPrincipal, CurrentCulture, CurrentUICulture, etc. Cela dépend-il de cadre (ASP.NET, WinForms, WCF, WPF)?

En général, SynchronizationContext ne garantit pas que la suite sera exécuté sur le même thread. Certains contextes pour que (WPF, Winforms), mais d'autres ne le font pas (ASP.NET).
Vous pouvez définir une valeur par défaut de la culture pour les threads comme ceci.

InformationsquelleAutor UserControl | 2012-09-17

asp.net-4.5 async-await c#conceptual multithreading

34

Suis-je correct que async/await lui-même n'a rien à faire avec la concurrence d'accès/parallélisme et n'est rien de plus que la mise en œuvre de la CPS?

Bien, async /await est une réécriture qui utilise CPS, afin de base de votre compréhension est correcte.

Sujet de la "simultanéité" et de "parallélisme", je dirais qu'il n'permettre la simultanéité; vous pouvez démarrer plusieurs async opérations qui sont tous "en vol" en même temps. C'est facile à faire avec Task.WhenAll et Task.WhenAny.

Aussi, même si async par lui-même ne signifie pas "multithreading", Task.Run ne facilitent async-compatible multithreading

Et le réel, le filetage est réalisé par SynchronizationContext instance qui les attendent de passe/restaure?

Pensez-y de cette façon: la poursuite créé par le CPS de réécriture a pour exécuter quelque part. La capture d'async "contexte" peut être utilisé pour planifier la suite.

Note de côté: la capture de contexte est en fait SynchronizationContext.Current , sauf si elle est nulle, auquel cas la capture d'contexte est TaskScheduler.Current.

Une autre remarque importante: la capture et de restauration du contexte est en fait à la "awaiter" objet. Donc, par défaut, si vous await un Task (ou tout autre intégré awaitable), le contexte sera capturé et restauré. Mais si vous await le résultat de ConfigureAwait(false), le contexte n'est pas capturé. De même, si vous await votre propre awaitable, il ne sera pas capturer le contexte (sauf si vous le programmer).

Cependant, il y a aucune garantie que le contexte du thread de l'information est conservée? Je veux dire le Nom, CurrentPrincipal, CurrentCulture, CurrentUICulture, etc.

SynchronizationContext est différent de celui ExecutionContext. Simplifié réponse est que ExecutionContext toujours des "flux", de sorte CurrentPrincipal flux (si elle n'a pas, il pourrait être un problème de sécurité, c'est pourquoi les Api qui ne coulent pas ExecutionContext toujours fin dans Unsafe).

Dans les applications d'INTERFACE utilisateur, la culture n'est pas le débit, mais par défaut, c'est la même chose pour tous les threads de toute façon. Name est certainement pas aller à l'écoulement, à moins que vous reprendre sur le même fil (p. ex., à l'aide d'une INTERFACE utilisateur SynchronizationContext).

Pour certains plus de la lecture, je vous recommande de commencer avec mon propre async /attendre tutoriel et puis le officiel async /attendre FAQ. Alors jetez un oeil à Stephen Toub le billet de blog de ExecutionContext au lieu de SynchronizationContext.

Vous pouvez également trouver mon SynchronizationContext article utile.
- Merci. Le lien de Stephen Toub le billet de blog de ExecutionContext vs SynchronizationContext a été extrêmement utile pour moi.
- Mec, vous êtes tous plus async. Comme partout. Nice!
InformationsquelleAutor Stephen Cleary

Non, le async/await mots-clés ont tout à voir avec la concurrence. async/await sont essentiellement constituées de votre code de la méthode à une tâche et la poursuite. Pour voir la traduction exacte que le compilateur produit (à l'aide de la Task Parallel Library) de démonter certains extrait de code. Cette traduction de async/await utilisation est "similaire" (mais pas identiques!) pour l'exemple ci-dessous

async Task<int> TaskOfTResult_MethodAsync()
{
    int hours;
    //. . .
    //Return statement specifies an integer result.
    return hours;
}

//Calls to TaskOfTResult_MethodAsync
Task<int> returnedTaskTResult = TaskOfTResult_MethodAsync();
int intResult = await returnedTaskTResult;
//or, in a single statement
int intResult = await TaskOfTResult_MethodAsync();

c'est approxiamtely converti à

private int Result()
{
    int hours;
    //. . .
    //Return statement specifies an integer result.
    return hours;
}

où vous attendez le retour à l'extérieur de la méthode comme

int? hours = null;
Task<int> task = null;
task = Task.Factory.StartNew<int>(() => Result());
task.ContnueWith(cont => 
{
    //Some task completion checking...
    hours = task.Result;
}, CancellationToken.None, 
   TaskCreationOptions.None, 
   TaskScheduler.Current);

Ou, vous pouvez placer le code TPL dans le Result méthode

private int ResultAsync()
{
    int? hours = null;
    Task<int> task = null;
    task = Task.Factory.StartNew<int>(() => 
    {
        int hours;
        //. . .
        //Return statement specifies an integer result.
        return hours;
    }, CancellationToken.None, 
       TaskCreationOptions.None, 
       TaskScheduler.Current);
    try
    {
        return task.Result;
    }
    catch (AggregateException aggEx)
    {
        //Some handler method for the agg exception.
        aggEx.Handle(HandleException); 
    }
}

SynchronizationContext ne garantit pas que la suite sera exécuté sur le même thread pour le async/awate code. Toutefois, vous pouvez définir le contexte à l'aide de TPL code, via le SynchronisationContex mot-clé.

InformationsquelleAutor MoonKnight

Vous devez vous connecter pour publier un commentaire.