Отключить кнопку, когда Задача завершена

У меня есть метод, который проверяет, можно ли нажать кнопку или нет, если мой путь к файлу или язык нулевой, я не включаю кнопку, и, конечно, когда мой путь к файлу выбран, я поднимаю событие.

Итак, прямо сейчас я выполняю некоторую работу в Azure и хочу отключить кнопку, когда начинаю свою работу, и включить ее, когда закончу свою работу.

Я пытался вызвать событие до вызова метода и после вызова, но он не включает кнопку

        public string? FilePath { get; set; }

        public bool IsWorking { get; set; }

        public Dictionary<int, Languages>? LanguagesDictionary { get; set; }

        public Visibility CanShow { get; set; }

        public DialogHelper DialogHelper { get; }

        public FolderHelper FolderHelper { get; }

        public AudioHelper AudioHelper { get; }

        public AzureTranscriptionService AzureTranscription { get; }

        public Command PickFileCommad { get; set; }

        public Command StartCommand { get; set; }

        private string? _SelectedItem;

        public string SelectedItem {
            get => _SelectedItem!;
            set {
                if (_SelectedItem != value) {
                    _SelectedItem = value;
                    StartCommand.RaiseCanExecuteChanged();
                }
            }
        }

        public AudioPageViewModel() {
            InitListLanguages();
            AzureTranscription = new AzureTranscriptionService();
            DialogHelper = new DialogHelper();
            FolderHelper = new FolderHelper();
            AudioHelper = new AudioHelper();
            CanShow = Visibility.Hidden;
            PickFileCommad = new Command(PickFileAction);
            StartCommand = new Command(StartAction, CanStartAction);
        }

        private bool CanStartAction(object arg) {
            if (string.IsNullOrEmpty(SelectedItem) ||
                string.IsNullOrEmpty(FilePath) ||
                IsWorking == true) {
                return false;
            }
            return true;
        }

        private async void StartAction(object obj) {

            var FileWithoutExtension = Path.GetFileNameWithoutExtension
                (FilePath);

            var AudioPath = FolderHelper.CreateFolder(ConstantsHelpers.AUDIO);

            var DocumentPath = FolderHelper.CreateFolder();

            var AudioFileNamePath = Path.Combine(AudioPath, $"{FileWithoutExtension}{ConstantsHelpers.WAV}");

            var ConvertedAudioPath = AudioHelper.Converter(FilePath!, AudioFileNamePath);

            var DocumentName = Path.Combine(DocumentPath, $"{FileWithoutExtension}{ConstantsHelpers.DOCX}");

            IsWorking = true;

            StartCommand.RaiseCanExecuteChanged();

            await AzureTranscription.ConvertToTextAsync(ConvertedAudioPath,
                SelectedItem, DocumentName);

            IsWorking = false;
            StartCommand.RaiseCanExecuteChanged();


        }

        private void PickFileAction() {
            var FullPath = DialogHelper.GetFilePath(ConstantsHelpers.AUDIO);
            FilePath = FullPath;

            StartCommand?.RaiseCanExecuteChanged();
        }

 public async Task ConvertToTextAsync(
            string FilePath,
            string Language,
            string WordDocName) {

            // Configure speech service

            var config = SpeechConfig.FromSubscription(ConstantsHelpers.AZURE_KEY, ConstantsHelpers.AZURE_REGION);
            config.SpeechRecognitionLanguage = Language;
            // Configure speech recognition

            var taskCompleteionSource = new TaskCompletionSource<int>();

            using var audioConfig = AudioConfig.FromWavFileInput(FilePath);
            using var speechRecognizer = new SpeechRecognizer(config, audioConfig);
            speechRecognizer.Recognizing += SpeechRecognizer_Recognizing;
            speechRecognizer.Recognized += SpeechRecognizer_Recognized;
            speechRecognizer.SessionStarted += SpeechRecognizer_SessionStarted;
            speechRecognizer.SessionStopped += SpeechRecognizer_SessionStopped;

            await speechRecognizer.StartContinuousRecognitionAsync().ConfigureAwait(false);

            Task.WaitAny(new[] { taskCompleteionSource.Task });

            await speechRecognizer.StopContinuousRecognitionAsync().ConfigureAwait(false);
        }

        private void SpeechRecognizer_SessionStopped(object? sender, SessionEventArgs e) {

            Debug.WriteLine("Stepped");
            var sb = new StringBuilder();

            foreach (var item in Letters) {
                sb.Append(item);
            }
        }

        private void SpeechRecognizer_SessionStarted(object? sender, SessionEventArgs e) {

            Debug.WriteLine("Started");
        }
        private void SpeechRecognizer_Recognized(object? sender, SpeechRecognitionEventArgs e) {
            if (e.Result.Reason == ResultReason.RecognizedSpeech) {
                foreach (var item in e.Result.Text) {
                    Letters.Add(item);
                }
            }
        }

        private void SpeechRecognizer_Recognizing(object? sender, SpeechRecognitionEventArgs e) {

            Debug.WriteLine(e.Result.Text);
        }
    }

Когда я начинаю работать, я выполняю этот код

Большое спасибо