C # UWP XAML – Mise à jour des contrôles «de manière synchrone»

Tout au long de cette question, j’ai inclus des liens qui montrent que j’ai déjà travaillé à la recherche d’une solution.

Je développe une application UWP avec écran tactile et GPIO.

L’interface utilisateur a un bouton d’arrêt, un bouton de réinitialisation et un bloc de texte. GPIO est utilisé pour un bouton de démarrage physique, un moteur et 2 fins de course. Le moteur peut tourner jusqu’à ce qu’il se heurte à un fin de course.

Un code pour contrôler le matériel (par exemple, Motor.Forward ()) a été écrit et testé, mais est exclu de cette question pour des raisons de brièveté. Le code du bouton d’arrêt est exclu pour la même raison.

• xUnit et Moq ne supportent pas async – attend des mots-clés
• ContinueWith perd le SynchronizationContext
• Le test NUnit avec une boucle d’application se bloque lorsque le formulaire est créé avant
• Faire fonctionner les interjecteurs Ninject avec des méthodes asynchrones
• Enregistrement d’une usine asynchrone dans Autofac

Si les étapes de ces méthodes fonctionnent de manière synchrone … le comportement souhaité peut être décrit par le code suivant:

//Event handler for when physical start button is pushed private async void StartButtonPin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args) { Start(); } private void Start() { //Update UI stopButton.IsEnabled = true; resetButton.IsEnabled = false; textBlock.Text = "Motor turning"; Motor.Forward(); while(Motor.HasNotHitEndLimit()) Motor.Off(); //Update UI stopButton.IsEnabled = false; resetButton.IsEnabled = true; textBlock.Text = "Task complete"; } //Event handler for reset button private void btnReset_Click() { //Update UI stopButton.IsEnabled = true; resetButton.IsEnabled = false; textBlock.Text = "Motor turning"; Motor.Back(); while(Motor.HasNotHitStartLimit()) Motor.Off(); //Update UI stopButton.IsEnabled = false; resetButton.IsEnabled = true; textBlock.Text = "Reset complete"; } 

Si je me souviens bien, les mises à jour de l’interface utilisateur au sein de “private void btnReset_Click ()” fonctionnent, mais elles ne sont pas synchrones … Autrement dit, toutes les mises à jour de l’interface utilisateur étaient terminées juste après “btnReset_Click ()”.

De la lecture des réponses à des questions similaires … il semble que les mises à jour de l’interface utilisateur dans “Start ()” échouent, car je ne suis pas sur le thread d’interface utilisateur (“L’application a appelé une interface qui a été organisée pour un autre thread.”). Il semble que le motif asynchrone de tâche soit une réponse courante à ce type de questions. Cependant, mes tentatives en ce sens ont donné des résultats étranges …

Le code ci-dessous est le plus proche du résultat souhaité. J’ai ajouté des tâches asynchrones utilisant CoreDispatcher pour gérer les mises à jour de l’interface utilisateur.

  //Task for updating the textblock in the UI private async Task UpdateText(ssortingng updateText) { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, new DispatchedHandler(() => { textBlock.Text = updateText; })); } //Task for enable/disable a given button private async Task UpdateButton(Button btn, bool shouldThisBeEnabled) { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, new DispatchedHandler(() => { btn.IsEnabled = shouldThisBeEnabled; })); } //Event handler for when physical start button is pushed private async void StartButtonPin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args) { Start(); } private void Start() { //Update UI UpdateButton(stopButton,true).Wait(); UpdateButton(resetButton,false).Wait(); UpdateText("Motor turning").Wait(); Motor.Forward(); while(Motor.HasNotHitEndLimit()) Task.Delay(1).Wait(); Motor.Off(); //Update UI UpdateButton(stopButton,false).Wait(); UpdateButton(resetButton,true).Wait(); UpdateText("Task complete").Wait(); } //Event handler for reset button private async void btnReset_Click() { //Update UI await UpdateButton(stopButton,true); await UpdateButton(resetButton,false); await UpdateText("Motor turning"); await Task.Delay(1); Motor.Back(); while(Motor.HasNotHitStartLimit()) await Task.Delay(1); Motor.Off(); //Update UI await UpdateButton(stopButton,false); await UpdateButton(resetButton,true); await UpdateText("Reset complete"); } 

Problèmes / idiosyncrasies avec le code ci-dessus (à part les erreurs de débutant que je pourrais faire en raison du fait que je commence juste avec C # … et du fait que cela semble trop compliqué et déroutant):

-Dans “Start ()” j’utilise .Wait () sur les tâches (parce que cela semble fonctionner, je ne comprends pas vraiment pourquoi …), et dans btnReset_Click (), il a été préférable de les attendre …

-btnReset_Click () n’est pas synchrone. Les mises à jour de l’interface utilisateur semblent être “un pas en arrière” … C’est-à-dire qu’en mode débogage, le bouton d’arrêt est activé lorsque je passe au-dessus de “wait UpdateButton (resetButton, false)”, le bouton de réinitialisation est désactivé lorsque j’interromps “attendent UpdateText (” Moteur tournant “)”, et ainsi de suite.

-Regarding btnReset_Click () … La boucle while dure BEAUCOUP plus de 1 milliseconde en temps réel, et pourtant, si je supprime tout “wait Task.Delay (1)”, les mises à jour de l’interface utilisateur sont “un pas en arrière”. Avec “wait Task.Delay (1)” inclus, les mises à jour de l’interface utilisateur sont “rattrapées” là où elles devraient être. Pourquoi “wait Task.Delay (1)” affecte-t-il les mises à jour de l’interface utilisateur de cette manière?

Si des personnes bien informées sont disposées à répondre à tout ou partie de cette question et me laisserons peut-être leur demander des précisions sur leurs réponses, je vous en serais très reconnaissant!

Question bonus …. J’ai également un bouton “Basculer le mode de test” sur l’écran tactile qui active une liste de boutons de l’interface utilisateur et en désactive un autre (basé sur un “testmode” statique de bool.). Je n’ai pas besoin d’utiliser TAP pour mettre à jour l’interface utilisateur ici , mais rappelez-vous que je veux le faire de manière synchrone (même si cela semble inutile dans cet exemple).

  private async void btnTestMode_Click(object sender, RoutedEventArgs e) { testMode = !testMode; if (testMode == true) { await UpdateButtons(TestModeButtons,true); await UpdateButtons(NormalModeButtons,false); return; } await UpdateButtons(TestModeButtons,true); await UpdateButtons(NormalModeButtons,false); } private async Task UpdateButtons(List btns, enable) { foreach (var btn in btns) { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, new DispatchedHandler(() => { btn.IsEnabled = enable; })); } } 

Comme il est écrit ci-dessus, cela se comporte comme btnReset_Click () … où les mises à jour de l’interface utilisateur sont “un pas en arrière”. Cependant, si j’ajoute “.ConfigureAwait (false)” à chaque attente dans le gestionnaire d’événements, il devient alors synchrone. J’ai lu un peu sur ce sujet, mais je ne le comprends pas encore tout à fait et j’aimerais beaucoup quelqu’un qui comprend mieux pour m’aider à le comprendre en ce qui concerne mon projet.

• Les fichiers enregistrés ne contiennent parfois que des caractères NUL
• Vouloir comprendre async
• Extensions réactives S’abonner appeler en attente
• Appel de méthodes asynchrones dans les filtres d’action dans MVC 5
• C # tâches asynchrones en attente indéfiniment