如何使用MVVM / ICommand模式在WPF中正确实现BackgroundWorker

Question

我有一个主要根据MVVM模式编写的小型WPF应用程序。 该程序的重​​点是读取文本文件的各行，从其中解析数据，将该数据写入对象列表，然后将这些对象中的数据写入特定格式的.CSV文件。

即使我已经以与其他应用程序相同的方式实现了BackgroundWorker类本身，但是这次我是从ICommand的Execute（）方法中调用RunWorkAsync（）方法。 当最终输出正确并且应用程序实际提供了所需的结果时，UI STILL将在BackgroundWorker运行时锁定。

我已经将我的BackgroundWorker成员和所有逻辑包装在一个名为“ ReaderWriter”的类中，其中包含一个将ViewModel作为参数的构造函数。

通过调用ReaderWriter实例的“ StartProcess”方法，将调用BackgroundWorker的RunWorkerAsync（），这是我希望它将接管另一个线程并执行长时间运行的过程，以读取源文件，解析数据的过程。 ，并写入新文件； 同时定期执行ReportProgress（）以更新ProgressBar。

这是我的ReaderWriter类的代码：

class ReaderWriter
{
    private LogDataViewModel vm { get; set; }
    private BackgroundWorker bw { get; set; }

    public ReaderWriter(LogDataViewModel viewModel)
    {
        vm = viewModel;
    }

    public void StartProcess()
    {
        bw = new BackgroundWorker();

        bw.WorkerReportsProgress = true;
        bw.WorkerSupportsCancellation = true;
        bw.DoWork += new DoWorkEventHandler(ReadFromSource);
        bw.ProgressChanged += new ProgressChangedEventHandler(UpdateProgress_Read);
        bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(Completed_Read);

        bw.RunWorkerAsync();
    }

    private void ReadFromSource(object sender, DoWorkEventArgs e)
    {
        double records = 0;
        string[] lines = File.ReadAllLines(vm.SourcePath);
        int lineCount = lines.Length;
        double currentLine = 0;

        bw.ReportProgress(0, lineCount);

        foreach (var line in lines)
        {
            if (line.Length > 0)
            {
                string syntax = line.Substring(17, 6);

                switch (syntax)
                {
                    case "$WIMDA":
                        string[] segments = line.Replace(": <- ", ",").Split(',');
                        vm.LineItems.Add(new LineItem()
                        {
                            Time = segments[0],
                            HgPressure = segments[2],
                            BarPressure = segments[4],
                            AirTemp = segments[6],
                            RelHumidity = segments[10],
                            TrueWindDir = segments[14],
                            KnotsWindSpeed = segments[18],
                            MpsWindSpeed = segments[20]
                        });
                        break;

                    case "$GPGGA":
                        break;

                    default:
                        break;
                }
            }
            currentLine++;
            bw.ReportProgress(1, currentLine);
        }
        using (StreamWriter writer = new StreamWriter(vm.OutputPath))
        {
            writer.WriteLine($"Time,Pressure(Bar),Pressure(Hg),AirTemp({((vm.ConvertTempSetting) ? "F" : "C")}),RelativeHumidity,TrueWindDirection,WindSpeed(Knots),WindSpeed(M/s)");
            foreach (var lineItem in vm.LineItems)
            {
                writer.WriteLine($"{lineItem.Time},{lineItem.BarPressure},{lineItem.HgPressure},{((vm.ConvertTempSetting) ? Converters.ConvertFromCelcius(Convert.ToDouble(lineItem.AirTemp)).ToString() : lineItem.AirTemp)},{lineItem.RelHumidity},{lineItem.TrueWindDir},{lineItem.KnotsWindSpeed},{lineItem.MpsWindSpeed}");
                records++;
            }
        }
        e.Result = records;
    }

    private void UpdateProgress_Read(object sender, ProgressChangedEventArgs e)
    {
        vm.IncrementProgress();
        switch (Type.GetTypeCode(e.UserState.GetType()))
        {
            case TypeCode.Double:
                vm.IncrementProgress();
                break;

            case TypeCode.String:
                break;

            case TypeCode.Int32:
                vm.AppendStatus(DateTime.Now, $"{(int)e.UserState} lines parsed from log file");
                break;

            default:
                break;
        }
        if (vm.IsFirst)
        {
            vm.ProgressIsVisible = true;
            vm.IncrementProgress();
            vm.SetMaximum((int)e.UserState);
            vm.IsFirst = false;
        }
    }
    private void Completed_Read(object sender, RunWorkerCompletedEventArgs e)
    {
        if (e.Cancelled)
        {
            vm.AppendStatus(DateTime.Now, $"Conversion was cancelled by user");
        }
        else
        {
            vm.AppendStatus(DateTime.Now, $"{(double)e.Result} records written to {vm.OutputPath}");
        }
        vm.LineItems.Clear();
    }
}

对于我的ViewModel：

public class LogDataViewModel : LogDataModel
{
    #region Commands
    public BeginProcessCommand BeginCommand { get; set; }
    public SelectOutputPathCommand OutputCommand { get; set; }
    public SelectSourceCommand SourceCommand { get; set; }
    public ResetCommand ResetCommand { get; set; }
    #endregion

    public bool IsFirst { get; set; }

    public LogDataViewModel()
    {
        BeginCommand = new BeginProcessCommand(this);
        OutputCommand = new SelectOutputPathCommand(this);
        SourceCommand = new SelectSourceCommand(this);
        ResetCommand = new ResetCommand(this);

        PrepareViewModel();
    }


    private void PrepareViewModel()
    {
        ProgressValue = 0;
        ProgressMaximum = 0;
        ProgressIsVisible = false;
        IsFirst = true;

        OutputPath = Properties.Settings.Default.RememberedSavePath;
        if (LineItems == null) LineItems = new List<LineItem>();
        if (StatusActions == null) StatusActions = new ObservableCollection<StatusAction>();
        AppendStatus(DateTime.Now, "Initialized Program");
    }
}

最后，这是命令：

public class BeginProcessCommand : ICommand
{
    LogDataViewModel vm;

    public BeginProcessCommand(LogDataViewModel viewModel)
    {
        vm = viewModel;
    }

    public event EventHandler CanExecuteChanged
    {
        add { CommandManager.RequerySuggested += value; }
        remove { CommandManager.RequerySuggested -= value; }
    }

    public bool CanExecute(object parameter)
    {
        bool result = true;

        if (!File.Exists(vm.SourcePath))
            result = false;
        try
        {
            if (!Directory.Exists(Path.GetDirectoryName(vm.SourcePath)))
                result = false;
        }
        catch
        {
            result = false;
        }
        return result;
    }

    public void Execute(object parameter)
    {
        ReaderWriter rw = new ReaderWriter(vm);
        rw.StartProcess();
    }
}

非常感谢此刻的任何帮助，因为我已经为此苦苦挣扎了一段时间，而且任何研究解决方案的尝试都无法满足我的特殊情况。 这似乎是一个非常独特的场景，但我希望我们能够使其成功。

谢谢！

Answer 1

您错误且频繁地（在文件的每一行中）使用ReportProgress。 它会受到重击，每次调用都会在您的UI中引起某种更新，从而将其锁定。

通过将百分比传递给ReportProgress ，可能最容易使用。 我不确定使用开关在UpdateProgress_Read中做什么。 最好仅在通过总行数的100时才进行更新。

将您的progressBar最大值设置为100

ProgressMaximum = 100;

计算您总行数的1％

var x = lineCount / 100;
var y = 0;

并且仅在您每通过1％时报告进度

currentLine++;
if((currentLine % x) == 0)
{
    y++;
    bw.ReportProgress(y);
}

并更改UpdateProgress_Read，使其递增

private void UpdateProgress_Read(object sender, ProgressChangedEventArgs e)
{
    vm.IncrementProgress();
}

您需要提供比x和y更佳的变量名！ 并弄清楚如果文件少于100行，该怎么办。