Le verrouillage de ressource avec async/await

J'ai une application dans laquelle j'ai une ressource partagée (un système de Mouvement) qui peut être accédé par plusieurs clients. J'ai Opérations individuelles qui nécessitent un accès au système pour la durée de la déplacer et qui devrait jeter "Occupé" des exceptions si des opérations sont demandés en même temps. J'ai aussi des Séquenceurs qui ont besoin d'un accès exclusif au système de Mouvement pour l'exécution de plusieurs Opérations, intercalés avec d'autres actions; au cours de la totalité de la séquence, pas d'autres clients doivent être en mesure d'exécuter les Opérations.

J'ai traditionnellement abordé ce problème à l'aide de Fil affinité, de sorte qu'un Thread peut demander un accès exclusif et exécuter le blocage des appels correspondant aux opérations. Tandis que le Thread a accès, aucun autre thread peut utiliser la ressource. Le problème que je vais avoir, c'est maintenant que j'ai déménagé vers la mise en œuvre de mon système à l'aide async/await modèles, afin de permettre plus propre séquenceur de mise en œuvre. Le problème est que maintenant mon séquenceur n'est pas toujours en cours d'exécution sur le même thread; le thread actif peut changer au cours de rappels, de sorte qu'il est plus facile de déterminer si je suis dans un contexte valide pour maintenir l'exécution des opérations. Un point à noter est que certains de ces Opérations elles-mêmes sont composées de attend, qui signifie à la fois les séquences et les Opérations peuvent s'étendre sur plusieurs threads.

Ma question: est ce que quelqu'un connais un bon modèle pour faire face à l'acquisition de l'accès exclusif à la présence de fil de commutation en raison de async/await?

De référence, quelques choses que j'ai vu:

1. Je pourrais créer un personnalisé SynchronizationContext qui mobilise toutes séquenceur appels pour la durée d'une séquence de revenir à un seul Thread. Ceci a l'avantage de me permettre de réutiliser mon thread existant affinité de la gestion de l'accès du code. L'inconvénient est qu'il faudrait consacrer un Thread à chaque fois que je ne soit une Séquence ou d'une Opération (depuis les Opérations peuvent aussi s'étendre sur plusieurs threads.)

2. Créer un ficier jeton d'accès pour passer à l'Opération de méthodes pour prouver que vous avez acquis de l'accès. Cela a l'inconvénient de ballonnements les méthodes avec un jeton de paramètre.

3. Utiliser le jeton d'accès de l'approche de (2), mais de créer une copie de l'interface de mise en œuvre pour les Opérations de l'interface de sorte qu'un wrapper peut être instancié avec le jeton 'cuit au four-in". Cela crée une certaine laid colle le code, mais il nettoie le séquenceur code de sorte qu'il n'a plus besoin de passer d'un jeton pour chaque méthode.