.NET GUI 在大量数据加载时冻结

Question

我是一名使用 .NET 框架的初级开发人员。

我正在处理一个问题，因为当我运行带有大量数据的应用程序时，我的 GUI 冻结了。

我有一个网格和一种用于记录字符串的输出文本框。网格中每条预期到达的消息都有一行。

然后，应用程序接收消息，网格更新与该消息对应的行中的单元格。另外，我在文本框中写入一个字符串，其中包含有关该消息的信息。

例如，文本框将包含以下消息：

10:23:45 Message 1 arrived and the result is OK
10:23:45 Message 2 arrived and the result is OK
10:23:45 Message 3 arrived and the result is FAIL
10:23:45 Message 4 arrived and the result is OK
10:23:46 Message 5 arrived and the result is OK
....

网格将类似于：

MESSAGE_ID | RESULT  <------- HEADER
Message_1  | OK
Message_2  | FAIL
Message_3  | OK
Message_4  | OK
Message_5  | OK
Message_6  | Waiting
Message_7  | Waiting
....

问题是，当我在很短的时间内收到多条消息时，GUI 会冻结，因为它一直在更新网格和文本盒子。它会冻结，直到所有消息到达并且网格和文本输出更新为止。

你知道是否有某种方法可以做到这一点，并且 GUI 不会冻结？使用多个线程来更新 GUI？

我认为这不是一个后台工作程序，因为 GUI 是应该完成这项工作的人，但也许我错了。

EDITED1：

事实上我有两个线程：

1）主线程。它是 GUI，它有一个 BlockingQueue。

private BlockingQueue _guiQueue = new BlockingQueue(1000);

2) 线程1 它接收消息，在接收到消息后执行一些工作，然后将结果排队并将其发送到 GUI：

_guiQueue.Enqueue(new UpdateResult(_message.Name, _message.Result));

我正在使用 BlockingQueues，这个： http://www.codeproject.com/KB/recipes/boundedblockingqueue.aspx

一旦主线程收到消息，它基本上会更新网格和输出文本框，仅此而已。

    public MainThread(IMainForm mainView)
    {
        // presenter 
        _mainView = mainView;
        ....
    // Blocking queues
        _guiQueue = new BlockingQueue(1000);
        ....
        // Timer
        logger.Debug("Initializing Timer");
        _timer = new DispatcherTimer();
        _timer.Interval = TimeSpan.FromMilliseconds(10);
        // Call handleMessages method everytime the timer wakes up
         _timer.Tick += HandleMessages;
        _timer.Start();
        ...
        // Order Passing Thread
        logger.Debug("Launching OPThread");
        _orderPassingThread = new OPThread(_OPQueue, _commonObjects);
        _orderPassingThreadProcess = new Thread(new ThreadStart(_orderPassingThread.OPThreadProcess));
        _orderPassingThreadProcess.Start();
        ...
     }

    private void HandleMessages(Object sender, EventArgs args)
    {
        Presenter.Messages.Message message;

        while ((message = _guiQueue.Dequeue(10)) != null)
        {
            switch (message.MessageType)
            {
                case messageTypes.updateResult:
                    UpdateResult updateStepMsg = (UpdateResult) message;          
                    _mainView.updateStepResult(updateStepMsg.Name, updateStepMsg.Result); // updates             Grid and text box           
         break;
            ....
                default:
                    break;
            }
        }
    }

问题

是当我每秒左右收到多条消息时。

例如，我有一个“停止”按钮来停止一切，但无法单击它，因为 GUI 被冻结了，

谢谢！

PS：我使用的是DevExpress，网格是XtraGrid，输出文本框是memoEdit控件

Answer 1

消息处理和 GUI 的常见反模式是立即响应收到的每条消息。更好的方法通常是在收到消息时对消息进行排队，然后仅定期更新 GUI，例如每 250 毫秒在计时器上更新一次。当您确实需要更新 UI 时，请使用有效的更新方法。许多专业的 UI 组件都有“BeginUpdate\EndUpdate”的概念，其中可以应用一批更改，而无需在应用每个更改时更新 UI。

更新

你不应该使用 ConcurrentQueue 吗？ BlockingQueue 将阻塞读取器（即在您的情况下，从外观上看是 UI），直到有可用数据为止。

Answer 2

1. 使用线程进行后台计算。 (BackGroundWorker)
2. 不要在每个新事件上更新屏幕，而是存储数据。运行一个计时器，以便每秒 X 次将当前数据写入屏幕。屏幕需要改变，以便人们看到有东西进来，而不是每秒数百次显示完全最新的信息。

Answer 3

您的消息接收代码的 CPU 密集程度如何？

尝试使用BackgroundWorker 线程来处理消息接收，然后才更新GUI。

这应该对您有所帮助。

干杯

Answer 4

我认为对您来说一个好的方法是使用 XtraGrid 教程之一中所示的解决方案。请查看 Demos\Components\XtraGrid\CS\GridTutorials\GridVirtualData 文件夹。它包含演示项目，展示如何有效地处理大数据。在此示例中，网格对于包含 100000 条记录的集合运行得非常快。网格行由索引表示，并且使用属性描述符获得实际值。因此，当加载网格时，它仅获取屏幕上可见的行。当网格滚动时，会动态访问附加数据。 属性的 getter 中设置断点

在对象 IList.this[int fIndex]

，您将看到网格有多智能:)。

要解冻 GUI，可以使用 Application.DoEvents() 方法。

我看到您正在使用 MemoEdit 来记录输入消息。它内部包含标准的多行文本框，并且该控件在处理大量内容时运行速度非常慢:(。如果我正确理解您的任务，您已经添加了编辑器以允许最终用户复制输入消息。如果我是您，我会替换XtraGrid 的 MemoEdit 允许您将多个选定记录中的数据复制到剪贴板。

我们对演示项目进行了轻微更改，这是我们最终得到的代码：

List<LogMessage> list = new List<LogMessage>();
for(int i = 0;i < 100000;i++) 
    list.Add(new LogMessage());
vList = new VirtualList(list);
grid.DataSource = vList;

...

    public class LogMessage {
        public LogMessage() {
            TimeStamp = DateTime.Now;
            Description = "Message at " + TimeStamp.Ticks.ToString();
        }
        public DateTime TimeStamp;
        public string Description;
    }

    public abstract class LogMessagePropertyDescriptor : PropertyDescriptor {
        bool fIsReadOnly;

        public LogMessagePropertyDescriptor(string fPropertyName, bool fIsReadOnly)
            : base(fPropertyName, null) {
            this.fIsReadOnly = fIsReadOnly;
        }

        public override bool CanResetValue(object component) { return false; }
        public override bool IsReadOnly {get { return fIsReadOnly; } }
        public override Type ComponentType { get { return typeof(LogMessage); } }
        public override void ResetValue(object component) {}
        public override bool ShouldSerializeValue(object component) { return true; }
    }
    public class LogMessageTimeStampPropertyDescriptor: LogMessagePropertyDescriptor {
        public LogMessageTimeStampPropertyDescriptor(bool fIsReadOnly)
            : base("TimeStamp", fIsReadOnly) {
        }
        public override Type PropertyType {get {return typeof(DateTime); } }
        public override object GetValue(object component) {
            LogMessage message = (LogMessage)component;
            return message.TimeStamp;
        }
        public override void SetValue(object component, object val) {
            LogMessage message = (LogMessage)component;
            message.TimeStamp = (DateTime)val;
        }
    }
    public class LogMessageDescriptionPropertyDescriptor: LogMessagePropertyDescriptor {
        public LogMessageDescriptionPropertyDescriptor(bool fIsReadOnly)
            : base("Description", fIsReadOnly) {
        }

        public override Type PropertyType { get { return typeof(string); } }

        public override object GetValue(object component) {
            LogMessage message = (LogMessage)component;
            return message.Description;
        }
        public override void SetValue(object component, object val) {
            LogMessage message = (LogMessage)component;
            message.Description = (string)val;
        }
    }
    public class VirtualList : IList, ITypedList {
        PropertyDescriptorCollection fColumnCollection;
        List<LogMessage> messages;

        public VirtualList(List<LogMessage> messages) {
            this.messages = messages;
            CreateColumnCollection();
        }
        public int RecordCount { get {return messages.Count; } }
        public int ColumnCount { get { return fColumnCollection.Count; } }
        protected virtual void CreateColumnCollection() {
            List<PropertyDescriptor> pds = new List<PropertyDescriptor>();
            pds.Add(new LogMessageTimeStampPropertyDescriptor(true));
            pds.Add(new LogMessageDescriptionPropertyDescriptor(false));
            fColumnCollection = new PropertyDescriptorCollection(pds.ToArray());
        }

        #region ITypedList Interface
        object IList.this[int fIndex] { get { return messages[fIndex]; } set { } }
        PropertyDescriptorCollection ITypedList.GetItemProperties(PropertyDescriptor[] descs) { return fColumnCollection; }
        string ITypedList.GetListName(PropertyDescriptor[] descs) { return ""; }
        #endregion
        #region IList Interface
        public virtual int Count { get { return RecordCount; } }
        public virtual bool IsSynchronized { get { return true; } }
        public virtual object SyncRoot { get { return true; } }
        public virtual bool IsReadOnly{ get { return false; } }
        public virtual bool IsFixedSize{ get { return true; } }
        public virtual IEnumerator GetEnumerator() { return null; }
        public virtual void CopyTo(System.Array array, int fIndex) {}
        public virtual int Add(object val) { throw new NotImplementedException(); }
        public virtual void Clear() { throw new NotImplementedException(); }
        public virtual bool Contains(object val) { throw new NotImplementedException(); }
        public virtual int IndexOf(object val) { throw new NotImplementedException(); }
        public virtual void Insert(int fIndex, object val) { throw new NotImplementedException(); }
        public virtual void Remove(object val) { throw new NotImplementedException(); }
        public virtual void RemoveAt(int fIndex) { throw new NotImplementedException(); }
        #endregion
    }