MVVM 的 WPF ProgressBar 可见性不起作用

Question

我有一个显示两个日期之间的记录列表的 WPF 窗口。我用于：MVVM Light、实体框架和存储过程。

当我运行显示列表的命令时，我想显示一个进度条来表示任务正在运行。查询完成后，我想隐藏进度条。 问题是进度条的可见性不好。以下是我的代码：

//XAML 
.
.
.
.
<StatusBar Grid.Row="2">

        <StatusBarItem Width="300">
            <TextBlock Text="{Binding SBMessage, UpdateSourceTrigger=PropertyChanged, Mode=TwoWay}"/>
        </StatusBarItem>

        <StatusBarItem Width="Auto">
            <Grid>
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="Auto"/>
                    <ColumnDefinition Width="Auto"/>
                </Grid.ColumnDefinitions>
                <TextBlock Text="Requête en cours..." Visibility="{Binding TaskInProgress, UpdateSourceTrigger=PropertyChanged, Mode=OneWay, Converter={StaticResource booltovisibility}}" />
            <ProgressBar 
                Visibility="{Binding TaskInProgress, UpdateSourceTrigger=PropertyChanged, Mode=OneWay, Converter={StaticResource booltovisibility}}" 
                Width="100" 
                Height="20" 
                IsIndeterminate="True"
                VerticalAlignment="Center"
                Grid.Column="1"
                />
            </Grid>

        </StatusBarItem>

    </StatusBar>


 //ViewModel

 bool _taskinprogress = false;
  public bool TaskInProgress
    {
        get { return _taskinprogress; }
        set
        {
            _taskinprogress = value;
            RaisePropertyChanged("TaskInProgress");
        }
    }

  public RelayCommand DisplaySimulationsListCommand
    {
        get
        {
            if (_splist == null)
                _splist = new RelayCommand(DisplaySimulationsListCommandExecute);
            return _splist;
        }
    }




    private void DisplaySimulationsListCommandExecute()
    {
        SBMessage = "Exécution...";
        TaskInProgress = true;
        Stopwatch stopWatch = new Stopwatch();
        stopWatch.Start();
        DoItWithStoredProcedure();
        stopWatch.Stop();
        TimeSpan ts = stopWatch.Elapsed;
        string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
        ts.Hours, ts.Minutes, ts.Seconds,
        ts.Milliseconds / 10);
        SBMessage = ListSimulations.Count().ToString() +  " Enregistrement(s) en : " + elapsedTime;
        CurrentDisplayedTab = 1;
        TaskInProgress = false;

        //SBMessage = "Prêt";
    }






    private void DoItWithStoredProcedure()
    {

        try
        {

            using (UnitOfWork cx = new UnitOfWork())
            {
                var ls = cx.GetSimulationsPeriode(VMPeriode.Debut, VMPeriode.Fin).AsReadOnly();
                ListSimulations = new ObservableCollection<Simulation>(ls);
                CVS = (ListCollectionView)CollectionViewSource.GetDefaultView(ListSimulations);
                RaisePropertyChanged("CVS");
            }
        }

        catch (Exception ex)
        {
            Messenger.Default.Send<ExceptionMessageRefresh>(new ExceptionMessageRefresh(ex), "DoItWithStoredProcedure");
        }
    }

//Converter
  public class BoolToVisiblityConverter : IValueConverter
    {
        #region Constructors
        /// <summary>
        /// The default constructor
        /// </summary>
        public BoolToVisiblityConverter() { }
        #endregion


        public bool Collapse { get; set; }

        #region IValueConverter Members
        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            bool bValue = (bool)value;
            if (bValue)
                return Visibility.Visible;
            else
            {
                if (Collapse)
                    return Visibility.Collapsed;
                else
                    return Visibility.Hidden;
            }
        }

        public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            Visibility visibility = (Visibility)value;

            if (visibility == Visibility.Visible)
                return true;
            else
                return false;
        }
        #endregion
    }

提前谢谢你。

Answer 1

公认的答案是他们在过去（.NET Framework 4 之前）是如何做到的，那时孩子们必须步行上山上下学。这是一个可读性更强的解决方案，不需要大量代码（感谢 .NET Framework 4/4.5）。

private void DoItWithStoredProcedure()
{
    //Do your normal SP stuff here
    //Instead, I mocked a synchronous method 
    Thread.Sleep(1000);
    Console.WriteLine("Completed");
}

private void DisplaySimulationsListCommandExecute()
{
    //Do stuff 
    Console.WriteLine("Started");
    TaskInProgress = true;
    Task.Run(() => DoItWithStoredProcedure())
        .ContinueWith( task => { TaskInProgress = false; });
    Console.WriteLine("Finished");
    //Do the rest of your stuff
}

输出：

Started   //Showed the ProgressBar animation 
Finished  //Task.Run was hit
Completed //ProgressBar became collapsed after ContinueWith is hit

证明：

正如您亲眼所见，这种被广泛接受的使用Task.Run 和ContinueWith 的方法是一种单行解决方案，可以很容易地阅读和理解。

Answer 2

您需要进行异步处理，因为一旦完成功能处理，所有 UI 级别的更改都将可用。在正常情况下，处理所需的时间可以忽略不计，因此这种情况并不明显。

建议更改：

// suggested changes start //
            delegate void LongTaskDelegate();
            private void DoItWithStoredProcedureAsync()
            {
                LongTaskDelegate del = new LongTaskDelegate(DoItWithStoredProcedure);
                AsyncCallback callback = new AsyncCallback(LongTaskFinishedCallback);
                IAsyncResult result = del.BeginInvoke(callback, null);
            }
            private void LongTaskFinishedCallback(IAsyncResult result)
            {
                TaskInProgress = false;
                ... some extra work
            }
// suggested changes end //    
            private void DisplaySimulationsListCommandExecute()
            {
                ...

                TaskInProgress = true;                    

                // call our new method declared above
                DoItWithStoredProcedureAsync();                     
            }

如果我们使用 async / await 模式，那么就没有通知之类的事件，我们必须用 TaskInProgress = false 污染我们的 DoItWithStoredProcedure()；这可以做到，但不是好的做法。我们当前的模式使用通知之类的事件，并通知我们长时间运行的任务完成。

Answer 3

@Habib Gherairi, 为避免阻塞 UI，您可能需要在绑定中添加“IsAsync=True”：

<ProgressBar Visibility="{Binding TaskInProgress, UpdateSourceTrigger=PropertyChanged, Mode=OneWay, Converter={StaticResource booltovisibility}, IsAsync=True}" IsIndeterminate="True" /

https://msdn.microsoft.com/en-us/library/system.windows.data.binding.isasync(v=vs.110).aspx

当绑定源属性的 get 访问器可能需要很长时间时，请使用 IsAsync 属性。一个示例是具有从 Web 下载的 get 访问器的图像属性。将 IsAsync 设置为 true 可避免在下载时阻塞 UI。