.net MVVM应用程序中的并发体系结构

我有一个客户端/服务器类型的应用程序设置，类似于bittorrent下载程序。但是，torrents会远程发送到客户端

共享数据的主要部分是要下载的文件列表（torrents）

我必须同时处理这些案件：

• 服务器（通过WCF）发送要下载的文件的更新列表，这意味着一些新文件将添加到列表中，一些文件将从列表中删除（有些文件保持不变）
• 同时，文件可能会完成下载/更改状态，因此列表中的项目需要使用新状态在本地更新
• 客户端上的本地事件可能会导致列表中的某些项过期，因此应将其删除

我使用的是MVVM体系结构，但我认为viewmodel应该与视图紧密对应，因此我添加了一个“服务”层，它目前是一组单例（我知道）。其中一个充当所述列表的共享资源，因此我有一个集合由多个线程更新

我想从单例转向依赖注入和不可变对象，以减少死锁、“删除/分离对象”和我所看到的数据完整性错误

但是，我不知道在哪里“保存”列表，以及如何管理来自不同线程的传入事件，这些线程可能会取消/否定/覆盖列表的当前处理

我正在寻找在高水平上处理这种情况的指针

---

我正在为列表中的项目使用实体框架，因为数据也需要持久化。

也许其他人可以提出您正在寻找的更简洁的设计，但我想知道您遇到的问题是否是多线程问题，而不是固有的设计缺陷。我实际上有点喜欢使用单例来管理列表的想法，但是让它为任何更改（这里想到的是一个ObservableCollection）引发事件，这将通知订阅这些事件的任何模型或VM。订阅这些事件时，使用Dispatcher为您管理线程同步等。没有什么可以阻止您将您的单例实例注入任何需要它的模型或虚拟机中

---

不利的一面是管理可能成为事件噩梦的事情，但我想知道是否有其他选择不会有类似的不利方面。

我最近为windows服务检查器做了类似的事情。它最终也很容易实现

在你的情况下，我认为有必要采取以下措施

文件-其唯一目的是下载文件并通知更改
FileManager—维护文件列表并添加新文件、删除文件等

public class File : INotifyPropertyChanged
    {
        private readonly string _fileName;
        private Thread _thread;
        private Task _task;
        private bool _cancelled;

        private TaskStatus _taskStatus;
        private int _taskProgress;
        private int _taskTotal;

        public event PropertyChangedEventHandler PropertyChanged;

        public File(string fileName)
        {
            _fileName = fileName;
            TaskStatus = TaskStatus.NotStarted;
        }

        public TaskStatus TaskStatus
        {
            get { return _taskStatus; }
            private set
            {
                _taskStatus = value;
                PropertyChanged.Raise(this, x => x.TaskStatus);
            }
        }

        public int TaskProgress
        {
            get { return _taskProgress; }
            private set
            {
                _taskProgress = value;
                PropertyChanged.Raise(this, x => x.TaskProgress);
            }
        }
        public int TaskTotal
        {
            get { return _taskTotal; }
            private set
            {
                _taskTotal = value;
                PropertyChanged.Raise(this, x => x.TaskTotal);
            }
        }

        public void StartTask()
        {
            _cancelled = false;

            //.Net 4 - task parallel library - nice
            _task = new Task(DownloadFile, TaskCreationOptions.LongRunning);
            _task.Start();

            //.Net Other
            _thread = new Thread(DownloadFile);
            _thread.Start();
        }

        public void CancelTask()
        {
            _cancelled = true;
        }

        private void DownloadFile()
        {
            try
            {
                TaskStatus = TaskStatus.Running;

                var fileLength = _fileName.Length;
                TaskTotal = fileLength;

                for (var i = 0; i < fileLength; i++)
                {
                    if (_cancelled)
                    {
                        TaskStatus = TaskStatus.Cancelled;
                        return;
                    }

                    //Some work to download the file
                    Thread.Sleep(1000); //sleep for the example instead 

                    TaskProgress = i;
                }

                TaskStatus = TaskStatus.Completed;

            }
            catch (Exception ex)
            {
                TaskStatus = TaskStatus.Error;
            }
        }
    }

    public enum TaskStatus
    {
        NotStarted,
        Running,
        Completed,
        Cancelled,
        Error
    }

    public static class NotifyPropertyChangedExtention
    {
        public static void Raise<T, TP>(this PropertyChangedEventHandler pc, T source, Expression<Func<T, TP>> pe)
        {
            if (pc != null)
            {
                pc.Invoke(source, new PropertyChangedEventArgs(((MemberExpression)pe.Body).Member.Name));
            }
        }
    }

公共类文件：INotifyPropertyChanged
{
私有只读字符串\u文件名；
私有线程(u线程),；
私人任务(u Task),；
私人住宅取消；
私有任务状态_TaskStatus；
私人国际事务进展；
私家车总装；
公共事件属性更改事件处理程序属性更改；
公共文件（字符串文件名）
{
_fileName=文件名；
TaskStatus=TaskStatus.NotStarted；
}
公共任务状态任务状态
{
获取{return\u taskStatus；}
专用设备
{
_任务状态=值；
PropertyChanged.Raise（这个，x=>x.TaskStatus）；
}
}
公共工程进展
{
获取{return\u taskProgress；}
专用设备
{
_任务进度=价值；
PropertyChanged.Raise（这个，x=>x.TaskProgress）；
}
}
公共int任务总数
{
获取{return\u taskTotal；}
专用设备
{
_taskTotal=价值；
PropertyChanged.Raise（这个，x=>x.TaskTotal）；
}
}
公共无效StartTask（）
{
_取消=错误；
//.NET4-任务并行库-尼斯
_任务=新任务（下载文件，TaskCreationOptions.LongRunning）；
_task.Start（）；
//.Net其他
_线程=新线程（下载文件）；
_thread.Start（）；
}
公共任务（）
{
_取消=真；
}
私有void下载文件（）
{
尝试
{
TaskStatus=TaskStatus.Running；
var fileLength=\u fileName.Length；
TaskTotal=文件长度；
对于（var i=0；i

这样做的好处是，您永远不需要从后台线程更新UI。您正在更新的是只读属性，只有后台类也将编写这些属性。本课程以外的任何内容都只能阅读，因此您不必担心锁定问题。UI绑定系统将收到以下通知：

public class FileManager
    {
        public ObservableCollection<File> ListOfFiles { get; set; }

        public void AddFile(string fileName)
        {
            var file = new File(fileName);
            file.PropertyChanged += FilePropertyChanged;
            file.StartTask();
            ListOfFiles.Add(file);
        }

        void FilePropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if (e.PropertyName == "TaskStatus")
            {
                var file = (File) sender;
                if (file.TaskStatus==TaskStatus.Completed)
                {
                    RemoveFile(file);// ??? automatically remove file from list on completion??
                }
            }
        }

        public void RemoveFile(File file)
        {
            if (file.TaskStatus == TaskStatus.Running)
            {
                file.CancelTask();
            }
            //unbind event
            file.PropertyChanged -= FilePropertyChanged;
            ListOfFiles.Remove(file);
        }
    }