使用線程和MVVM將高速數據流式傳輸到WPF UI

Question

使用新的WPF應用程序時出現問題，該應用程序試圖向文本框顯示高速字節流。 字節來自串行端口，我制作了一個較舊的WinForms應用程序，該應用程序可以很好地處理該流，並具有從串行端口讀取並通過調用委托發布到UI的后台線程。

現在，此WPF應用程序存在的問題是我正在使用基本的MVVM方法。 我將UI上的文本框綁定到VM上的一個屬性，該屬性觸發基於INotifyPropertyChanged的PropertyChanged事件。 當數據准備通過讀取串行端口的服務上的已訂閱事件發布到ui時，我將使用以下命令：

Action dispatchAction = () => { FormattedStream += s; };
_currentDispatcher.Invoke(dispatchAction);

FormattedStream是UI綁定到的VM字符串屬性。

WPF應用程序發生的情況與WinForms版本中未發生的情況一樣，是WPF應用程序在運行過程中變得緩慢且無響應，並且與WinForms應用程序和wpf應用程序一樣無法跟上潮流根據我的任務管理器使用/需要更多處理器。

我想知道的是，是否有某種解決方案來處理流到WPF UI的流（高速）數據。

預計到達時間：我還嘗試使用BeginInvoke代替Invoke，當使用BeginInvoke時，流持續幾秒鍾然后凍結。 調用是獲得連續流到UI的唯一方法。

ETA：這是代碼：

//窗口/視圖

public partial class MainWindow : Window, IView
{
  public MainWindow()
  {
     InitializeComponent();
  }

  public IViewModel ViewModel
  {
     get { return DataContext as IViewModel; }
     set { DataContext = value; }
  }

  public void ScrollToCaret()
  {
     txtBoxOutPut.ScrollToEnd();

     if (txtBoxOutPut.Text.Length > 10000)
        txtBoxOutPut.Text = txtBoxOutPut.Text.Remove(0, 9000);
  }

  public event Action ComPortSelected;
  public event Action StartPortReader;
  public event Action StopPortReader;


  private void Start_Click(object sender, RoutedEventArgs e)
  {
     StartPortReader.Invoke();
  }

  private void Stop_Click(object sender, RoutedEventArgs e)
  {
     StopPortReader.Invoke();
  }

}

// ViewModel

public class ViewModel : IViewModel, INotifyPropertyChanged

{私人唯讀ISerialPortReaderService _portReaderService; 私有只讀Dispatcher _currentDispatcher;

  public ViewModel(IView view, ISerialPortReaderService portReaderService)
  {
     View = view;
     View.ViewModel = this;
     View.StartPortReader += View_StartPortReader;
     View.StopPortReader += View_StopPortReader;
     _portReaderService = portReaderService;
     _currentDispatcher = Dispatcher.CurrentDispatcher;
     _portReaderService.ByteArrived += _portReaderService_ByteArrived;
  }

  private void _portReaderService_ByteArrived(string s)
  {
     Action dispatchAction = () => { FormattedStream = s; };
     _currentDispatcher.Invoke(dispatchAction);
  }

  private void View_StopPortReader()
  {
     _portReaderService.Stop();
  }

  private void View_StartPortReader()
  {
     _portReaderService.Start(SelectedPort);
  }

  public IView View { get; private set; }

  public void ShowView()
  {
     View.Show();
  }

  private StringBuilder _FormattedStream = new StringBuilder();
  public string FormattedStream
  {
     get
     {
        return _FormattedStream.ToString();
     }
     set
     {
        _FormattedStream.Append(value);
        PropertyChanged(this, new PropertyChangedEventArgs("FormattedStream"));
        View.ScrollToCaret();
     }
  }

  private string _SelectedPort;
  public string SelectedPort
  {
     get
     {
        return _SelectedPort;
     }
     set
     {
        _SelectedPort = value;
        PropertyChanged(this, new PropertyChangedEventArgs("SelectedPort"));
     }
  }

  public ReadOnlyCollection<string> AvailablePorts
  {
     get { return GetAvailablePorts(); }
  }

  private ReadOnlyCollection<string> GetAvailablePorts()
  {
     var ports = System.IO.Ports.SerialPort.GetPortNames();
     return new ReadOnlyCollection<string>(ports.ToList());
  }

  public event PropertyChangedEventHandler PropertyChanged = delegate { };

}

//串口讀卡器服務

public class SerialPortReaderService : ISerialPortReaderService

{private SerialPort _port = new SerialPort（）; 私有只讀IThreadRunner _threadRunner;

  public SerialPortReaderService(IThreadRunner threadRunner)
  {
     _threadRunner = threadRunner;
  }

  public void Start(string comPort)
  {
     if (_port != null && !_port.IsOpen)
     {
        _port.PortName = comPort;
        _port.BaudRate = 4800;            
        _port.Open();

        _threadRunner.Start(() =>
                               {

                                     var b = new byte[20];
                                     var bArray = _port.Read(b, 0, 20);
                                     foreach (var b1 in b)
                                     {
                                        next10Bytes.Append(b1 + ", ");
                                     }                                        

                                     BytesArrived(next10Bytes.ToString());
                                     next10Bytes.Clear();

                                     Thread.Sleep(10);

                               });
     }
  }

  private StringBuilder next10Bytes = new StringBuilder();

  public void Stop()
  {
     if (_port.IsOpen)
     {
        _threadRunner.Stop();
        _port.Close();
     }
  }

  public event Action<string> BytesArrived;

}

//我使用的線程運行器

public class ThreadRunner : IThreadRunner

{私有線程_thread; 私人布爾值_isRunning;

  /// <summary>
  /// Will continuously run in a while loop the action submitted in a separate thread
  /// </summary>
  /// <param name="toDoAction"></param>
  public void Start(Action toDoAction)
  {
     if (_thread != null && _thread.IsAlive)
        Stop();

     _isRunning = true;

     _thread = new Thread(() =>
                             {
                                while (_isRunning)
                                {
                                   toDoAction.Invoke();
                                }
                             });
     _thread.Start();
  }

  public void Stop()
  {
     _isRunning = false;
     if (_thread != null && _thread.IsAlive)
     {
        _thread.Abort();
        _thread.Join(new TimeSpan(0, 0, 1));
     }
  }

  public bool ThreadIsRunning
  {
     get { return _isRunning; }
  }

}

Answer 1

根據Petoj所說的，我創建了一個新窗口，仍在使用流服務，但僅窗口本身訂閱了bytesarrived事件並通過Dispatcher手動附加到txtbox上。沒有大量的CPU使用率。

這個故事的寓意是，每次添加新的字符串時，不斷綁定或至少綁定到字符串會導致速度變慢。