c# - 计算进度逻辑应该驻留在服务层吗？

Question

在我的 WPF 应用程序中，我的 ViewModel 与 ViewModelService 对话，ViewModelService 又与 CalculationService 对话，以检索要在 View 中呈现的已处理数据。我希望 View 能够向用户报告完成百分比。我的问题有两个方面。

首先是这个逻辑应该放在哪里？ CalculationService 是否应该负责报告进度以及实际结果，或者 ViewModel 服务是否计算进度百分比详细信息。

其次，我发现我可以使用 TPL 或使用 ReactiveExtentions 来实现这一点。我倾向于响应式(Reactive)扩展，因为在我的例子中，计算服务的 API 和实现看起来像这样

//This is pseudo code, just aiming to show my intention here
    IEnumerable<Output> Calculate(IEnumerable<Inputs> inputs){
             List<Output> output = new List<Output>();
             foreach(var input : inputs){
               //long running calculation, which produces output
               //outputs.Add(output)
             }
           }

我假设如果我走 Reactive 路线，我可以使用 Reactive 的 OnNext 来流式传输“输出”，当它们到达时，我也可以使用 Parallel.Foreach 来获得性能。

对此有什么想法或想法吗？

谢谢凯

Answer 1

我觉得view model层计算进度就可以了。

这是我用 Rx 做的:

首先创建一个Progress<T>上课 Output变成可以报告自己进度的类型。

public class Progress<T>
{
    public Progress(T value, int current, int total)
    {
        this.Value = value;
        this.Current = current;
        this.Total = total;
    }
    public T Value { get; private set; }
    public int Current { get; private set; }
    public int Total { get; private set; }
    public double Percentage
    {
        get
        {
            return (double)this.Current / (double)this.Total;
        }
    }
}

现在您只需要 Calculate方法。

public IObservable<Progress<Output>> Calculate(IEnumerable<Inputs> inputs)
{
    return
        Observable
            .Create<Progress<Output>>(o =>
            {
                var source = inputs.ToArray();
                var total = source.Length;
                return
                    source
                        .ToObservable()
                        .Select((x, n) =>
                            new Progress<Output>(LongRunningCalculation(x), n, total))
                        .Subscribe(o);
            });     
}

这不会带来任何性能提升，但我肯定不会使用 Parallel.ForEach得到任何改进。混合任务、可枚举对象和可观察对象并不是最好的。坚持一种范式总是更好。

下面是我将如何使它并行运行。

IObservable<Progress<Output>> Calculate(IEnumerable<Inputs> inputs)
{
    return
        Observable
            .Create<Progress<Output>>(o =>
            {
                var source = inputs.ToArray();
                var total = source.Length;
                return
                    source
                        .ToObservable()
                        .SelectMany(x => Observable.Start(() => LongRunningCalculation(x)))
                        .Select((x, n) => new Progress<Output>(x, n, total))
                        .Subscribe(o);
            });     
}