Question

背景

我使用的RichTextBox控件基本上就像我的WinForms应用程序中的控制台一样。目前，我的应用程序范围的记录器使用委托发布消息，其中一个侦听器是此RTB。记录器同步发送大量短（少于100个字符）字符串，表示事件调用，状态消息，操作结果等。

使用BeginInvoke向RTB发布大量这些短消息，提供UI响应，直到大量并行处理开始记录大量消息，然后UI开始不按顺序发布项目，或者文本远远落后（数百毫秒）。我知道这一点，因为当处理速度减慢或停止时，控制台会在一段时间后继续写字。

我的临时解决方案是同步调用UI并添加阻塞收集缓冲区。基本上从Logger获取许多小项目并将它们组合在一个字符串构建器中，以便汇总到RTB中。如果UI可以跟上，缓冲区会在项目到来时发布，但如果队列过高，则会聚合它们，然后发布到UI。因此，当记录大量的东西时，RTB更新了零食并且看起来很跳跃。

问题

如何在自己的UI线程上运行RichTextBox控件，以便在频繁但小的追加操作期间保持其他按钮在同一Form响应？从研究中，我认为我需要运行一个STA线程并在其上调用Application.Run()将RTB放在自己的线程上，但我发现的示例缺少实质性的代码示例，似乎没有任何教程（也许是因为我想要做的是不明智的？）。此外，我不确定单个控件是否存在与其自身表单相关的自身线程中的任何陷阱。（即关闭主窗体的任何问题，或者RTB的STA线程是否会因窗体关闭而死亡？任何特殊处理？等等。）

一旦您向表单添加3 Button和RichTextBox，就会显示此问题。我本质上想要完成的是通过将RTB放在自己的线程上来分解BufferedConsumer。大部分代码都是从我的主应用程序中逐字删除的，所以是的，它很丑陋。

    using System;
    using System.Collections.Concurrent;
    using System.Diagnostics;
    using System.Drawing;
    using System.Runtime.InteropServices;
    using System.Text;
    using System.Threading;
    using System.Threading.Tasks;
    using System.Windows.Forms;

namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        // Fields
        private int m_taskCounter;
        private static CancellationTokenSource m_tokenSource;
        private bool m_buffered = true;
        private static readonly object m_syncObject = new object();

        // Properties
        public IMessageConsole Application_Console { get; private set; }
        public BufferedConsumer<StringBuilder, string> Buffer { get; private set; }

        public Form1()
        {
            InitializeComponent();

            m_tokenSource = new CancellationTokenSource();
            Application_Console = new RichTextBox_To_IMessageConsole(richTextBox1);

            Buffer =
                new BufferedConsumer<StringBuilder, string>(
                  p_name: "Console Buffer",
                  p_appendBuffer: (sb, s) => sb.Append(s),
                  p_postBuffer: (sb) => Application_Console.Append(sb));

            button1.Text = "Start Producer";
            button2.Text = "Stop All";
            button3.Text = "Toggle Buffering";

            button1.Click += (o, e) => StartProducerTask();
            button2.Click += (o, e) => CancelAllProducers();
            button3.Click += (o, e) => ToggleBufferedConsumer();
        }

        public void StartProducerTask()
        {
            var Token = m_tokenSource.Token;
            Task
                .Factory.StartNew(() =>
                {
                    var ThreadID = Interlocked.Increment(ref m_taskCounter);
                    StringBuilder sb = new StringBuilder();

                    var Count = 0;
                    while (!Token.IsCancellationRequested)
                    {
                        Count++;
                        sb.Clear();
                        sb
                            .Append("ThreadID = ")
                            .Append(ThreadID.ToString("000"))
                            .Append(", Count = ")
                            .AppendLine(Count.ToString());

                        if (m_buffered)
                            Buffer
                                .AppendCollection(sb.ToString()); // ToString mimicks real world Logger passing strings and not stringbuilders
                        else
                            Application_Console.Append(sb);

                        Sleep.For(1000);
                    }
                }, Token);
        }
        public static void CancelAllProducers()
        {
            lock (m_syncObject)
            {
                m_tokenSource.Cancel();
                m_tokenSource = new CancellationTokenSource();
            }
        }
        public void ToggleBufferedConsumer()
        {
            m_buffered = !m_buffered;
        }
    }

    public interface IMessageConsole
    {
        // Methods
        void Append(StringBuilder p_message);
    }

    // http://stackoverflow.com/a/5706085/1718702
    public class RichTextBox_To_IMessageConsole : IMessageConsole
    {
        // Constants
        private const int WM_USER = 0x400;
        private const int WM_SETREDRAW = 0x000B;
        private const int EM_GETEVENTMASK = WM_USER + 59;
        private const int EM_SETEVENTMASK = WM_USER + 69;
        private const int EM_GETSCROLLPOS = WM_USER + 221;
        private const int EM_SETSCROLLPOS = WM_USER + 222;

        //Imports
        [DllImport("user32.dll")]
        private static extern IntPtr SendMessage(IntPtr hWnd, Int32 wMsg, Int32 wParam, ref Point lParam);

        [DllImport("user32.dll")]
        private static extern IntPtr SendMessage(IntPtr hWnd, Int32 wMsg, Int32 wParam, IntPtr lParam);

        // Fields
        private RichTextBox m_richTextBox;
        private bool m_attachToBottom;
        private Point m_scrollPoint;
        private bool m_painting;
        private IntPtr m_eventMask;
        private int m_suspendIndex = 0;
        private int m_suspendLength = 0;

        public RichTextBox_To_IMessageConsole(RichTextBox p_richTextBox)
        {
            m_richTextBox = p_richTextBox;
            var h = m_richTextBox.Handle;

            m_painting = true;

            m_richTextBox.DoubleClick += RichTextBox_DoubleClick;
            m_richTextBox.MouseWheel += RichTextBox_MouseWheel;
        }

        // Methods
        public void SuspendPainting()
        {
            if (m_painting)
            {
                m_suspendIndex = m_richTextBox.SelectionStart;
                m_suspendLength = m_richTextBox.SelectionLength;
                SendMessage(m_richTextBox.Handle, EM_GETSCROLLPOS, 0, ref m_scrollPoint);
                SendMessage(m_richTextBox.Handle, WM_SETREDRAW, 0, IntPtr.Zero);
                m_eventMask = SendMessage(m_richTextBox.Handle, EM_GETEVENTMASK, 0, IntPtr.Zero);
                m_painting = false;
            }
        }
        public void ResumePainting()
        {
            if (!m_painting)
            {
                m_richTextBox.Select(m_suspendIndex, m_suspendLength);
                SendMessage(m_richTextBox.Handle, EM_SETSCROLLPOS, 0, ref m_scrollPoint);
                SendMessage(m_richTextBox.Handle, EM_SETEVENTMASK, 0, m_eventMask);
                SendMessage(m_richTextBox.Handle, WM_SETREDRAW, 1, IntPtr.Zero);
                m_painting = true;
                m_richTextBox.Invalidate();
            }
        }
        public void Append(StringBuilder p_message)
        {
            var WatchDogTimer = Stopwatch.StartNew();
            var MinimumRefreshRate = 2000;

            m_richTextBox
                .Invoke((Action)delegate
                {
                    // Last resort cleanup
                    if (WatchDogTimer.ElapsedMilliseconds > MinimumRefreshRate)
                    {
                        // m_richTextBox.Clear(); // Real-world behaviour

                        // Sample App behaviour
                        Form1.CancelAllProducers();
                    }

                    // Stop Drawing to prevent flickering during append and
                    // allow Double-Click events to register properly
                    this.SuspendPainting();
                    m_richTextBox.SelectionStart = m_richTextBox.TextLength;
                    m_richTextBox.SelectedText = p_message.ToString();

                    // Cap out Max Lines and cut back down to improve responsiveness
                    if (m_richTextBox.Lines.Length > 4000)
                    {
                        var NewSet = new string[1000];
                        Array.Copy(m_richTextBox.Lines, 1000, NewSet, 0, 1000);
                        m_richTextBox.Lines = NewSet;
                        m_richTextBox.SelectionStart = m_richTextBox.TextLength;
                        m_richTextBox.SelectedText = "\r\n";
                    }
                    this.ResumePainting();

                    // AutoScroll down to display newest text
                    if (m_attachToBottom)
                    {
                        m_richTextBox.SelectionStart = m_richTextBox.Text.Length;
                        m_richTextBox.ScrollToCaret();
                    }
                });
        }

        // Event Handler
        void RichTextBox_DoubleClick(object sender, EventArgs e)
        {
            // Toggle
            m_attachToBottom = !m_attachToBottom;

            // Scroll to Bottom
            if (m_attachToBottom)
            {
                m_richTextBox.SelectionStart = m_richTextBox.Text.Length;
                m_richTextBox.ScrollToCaret();
            }
        }
        void RichTextBox_MouseWheel(object sender, MouseEventArgs e)
        {
            m_attachToBottom = false;
        }
    }

    public class BufferedConsumer<TBuffer, TItem> : IDisposable
        where TBuffer : new()
    {
        // Fields
        private bool m_disposed = false;
        private Task m_consumer;
        private string m_name;
        private CancellationTokenSource m_tokenSource;
        private AutoResetEvent m_flushSignal;
        private BlockingCollection<TItem> m_queue;

        // Constructor
        public BufferedConsumer(string p_name, Action<TBuffer, TItem> p_appendBuffer, Action<TBuffer> p_postBuffer)
        {
            m_name = p_name;
            m_queue = new BlockingCollection<TItem>();
            m_tokenSource = new CancellationTokenSource();
            var m_token = m_tokenSource.Token;
            m_flushSignal = new AutoResetEvent(false);

            m_token
                .Register(() => { m_flushSignal.Set(); });

            // Begin Consumer Task
            m_consumer = Task.Factory.StartNew(() =>
            {
                //Handler
                //    .LogExceptions(ErrorResponse.SupressRethrow, () =>
                //    {
                // Continuously consumes entries added to the collection, blocking-wait if empty until cancelled
                while (!m_token.IsCancellationRequested)
                {
                    // Block
                    m_flushSignal.WaitOne();

                    if (m_token.IsCancellationRequested && m_queue.Count == 0)
                        break;

                    // Consume all queued items
                    TBuffer PostBuffer = new TBuffer();

                    Console.WriteLine("Queue Count = " + m_queue.Count + ", Buffering...");
                    for (int i = 0; i < m_queue.Count; i++)
                    {
                        TItem Item;
                        m_queue.TryTake(out Item);
                        p_appendBuffer(PostBuffer, Item);
                    }

                    // Post Buffered Items
                    p_postBuffer(PostBuffer);

                    // Signal another Buffer loop if more items were Queued during post sequence
                    var QueueSize = m_queue.Count;
                    if (QueueSize > 0)
                    {
                        Console.WriteLine("Queue Count = " + QueueSize + ", Sleeping...");
                        m_flushSignal.Set();

                        if (QueueSize > 10 && QueueSize < 100)
                            Sleep.For(1000, m_token);      //Allow Queue to build, reducing posting overhead if requests are very frequent
                    }
                }
                //});
            }, m_token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
        }
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
        protected virtual void Dispose(bool p_disposing)
        {
            if (!m_disposed)
            {
                m_disposed = true;
                if (p_disposing)
                {
                    // Release of Managed Resources
                    m_tokenSource.Cancel();
                    m_flushSignal.Set();
                    m_consumer.Wait();
                }
                // Release of Unmanaged Resources
            }
        }

        // Methods
        public void AppendCollection(TItem p_item)
        {
            m_queue.Add(p_item);
            m_flushSignal.Set();
        }
    }

    public static partial class Sleep
    {
        public static bool For(int p_milliseconds, CancellationToken p_cancelToken = default(CancellationToken))
        {
            //p_milliseconds
            //    .MustBeEqualOrAbove(0, "p_milliseconds");

            // Exit immediate if cancelled
            if (p_cancelToken != default(CancellationToken))
                if (p_cancelToken.IsCancellationRequested)
                    return true;

            var SleepTimer =
                new AutoResetEvent(false);

            // Cancellation Callback Action
            if (p_cancelToken != default(CancellationToken))
                p_cancelToken
                    .Register(() => SleepTimer.Set());

            // Block on SleepTimer
            var Canceled = SleepTimer.WaitOne(p_milliseconds);

            return Canceled;
        }
    }
}

Answer 1

根据OP的要求发布答案：

您可以使用my example

在现有的winforms应用程序中集成ElementHost虚拟化，高性能，丰富，高度可自定义的WPF日志查看器

enter image description here

上面链接中的完整源代码

在自己的线程上运行RichTextBox？

1 个答案: