调用异步方法后，进程似乎没有 go 回到 WPF 应用程序中的主线程

Question

I'm new to both WPF and threading, and this is partly based on code I have not made, so I'm not even able to ask the right questions or know where to look.

I have a application with a toggle button that can stop and start some services.

When you start up the app, the services are running. You can then click the button to stop them. While waiting for the services to stop (or start) the button is disabled. When all services have transitioned from one state to another, the text on the button changes, and the button is supposed to be enabled, except it does not, the text is being changed, but the button does not become enabled. However, if I click anywhere on the GUI, the button becomes enabled. And this leads me to think that the clicking somehow (re)acivates a thread.

Comments to the code

In the constructor, I refer to the method CanServicesExecute() whether the button is enabled or not. So while the program is running this method is being hit all the time by the system.

The part that checks if the services are running is done by a separate thread in order not the block the rest of the GUI, but only disabling the one button. It checks every 5 sec.

In this code I have substituted the actual checking if services have terminated or stopped with a simple wait, but my problem remains: After the Thread.Sleep, the Servicesstate is being set, and the button IS getting another text, but the CanServicesExecute() is no longer being hit. Until I click somewhere in the GUI, and then it is being hit constantly again.

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;
using Contracts.Annotations;
using Contracts.BusinessObjects;
using eDeployment.Properties;
using eTray.Common;
using eTray.Server;
using eTray.Types.Server;
using Infrastructure.Commands;
using Settings = eDeployment.Properties.Settings;

namespace eDeployment.ViewModel
{
    public class DeploymentViewModel : INotifyPropertyChanged
    { 

        enum ServicesState
        {
            Running = 0,
            Terminated = 1,
            Transitioning = 2,
            Unfinished = 3
        }

        
        private ServicesState IsServicesRunning { get; set; }


        public DeploymentViewModel()
        {
            StopStartServicesCommand = new RelayCommand<object>(_ => StopStartServices(), _ => CanServicesExecute());
        }

        private void StopStartServices()
        {
            if (IsServicesRunning == ServicesState.Running)
                StopServicesCommand();
            else
            {
                StartServicesCommand();
            }
        }

        private async void StopServicesCommand()
        {
            SetServiceState(ServicesState.Transitioning, Resources.TryStopServices);
            //CheckServicesX(false);
            CheckServicesProcessX(true);
        }

        private async void StartServicesCommand()
        { 
            SetServiceState(ServicesState.Transitioning, Resources.TryStartServices);
            LogWrite(Resources.TryStartServices, false);
            //CheckServicesX(true);
            CheckServicesProcessX(true);
        }

        private async void CheckServicesProcessX(bool starting)
        {
           await Task.Run(() => CheckServicesX(starting))
               .ContinueWith(t => { }, TaskScheduler.FromCurrentSynchronizationContext());

        }


        private  void CheckServicesX(bool starting)
        {
            Thread.Sleep(3000); 
            
                if (!starting)
                {
                    SetServiceState(ServicesState.Terminated, Resources.ServicesTerminated);
                    LogWrite(Resources.ServicesTerminated, false);
                    
                }
                else
                {
                     SetServiceState(ServicesState.Running, Resources.ServicesRunning);
                    LogWrite(Resources.ServicesRunning, false);
                   
                }
        }
        
        private async void CheckServicesY(bool starting)
        {
            
             await Task.Delay(3000); 
            
                if (!starting)
                {

                    SetServiceState(ServicesState.Terminated, Resources.ServicesTerminated);
                    LogWrite(Resources.ServicesTerminated, false);
                    
                }
                else
                {
                     SetServiceState(ServicesState.Running, Resources.ServicesRunning);
                    LogWrite(Resources.ServicesRunning, false);
                   
                }
        }

        private void SetServiceState(ServicesState servicestate, string message)
        {
            switch (servicestate)
            {
                case ServicesState.Running:
                    IsServicesRunning = ServicesState.Running;
                    ColorIndicator = "Green";
                    ServicesLabel = Resources.LabeL_StopServices;

                    break;
                case ServicesState.Transitioning:
                    IsServicesRunning = ServicesState.Transitioning;
                    ColorIndicator = "Orange";

                    break;
                case ServicesState.Terminated:
                    IsServicesRunning = ServicesState.Terminated;
                    ServicesLabel = Resources.LabeL_StartServices;
                    ColorIndicator = "Red";

                    break;
                case ServicesState.Unfinished:
                    IsServicesRunning = ServicesState.Terminated;
                    ColorIndicator = "Orange";

                    break;
            }

            ServiceStatusText = message;
        }


        private bool CanServicesExecute()
        {
            if (IsServicesRunning == ServicesState.Transitioning)
                return false;
            return true;
        }
    }
}

Answer 1

You need to make sure that CanServicesExecute is called whenever you want to refresh the status of the Button that is bound to the StopStartServicesCommand . You do this by raising the command's CanExecuteChanged event.

How to raise the event depends on the implementation of the RelayCommand<T> class that you are using. It should have a public method that raises the event:

StopStartServicesCommand.RaiseCanExecuteChanged();

Call this one in CheckServicesX or whenever you want to enable or disable the Button based on the current status.