在 WPF 中的线程

线程处理使程序能够执行并发处理，以便它可以做多个操作一次。节省开发人员从线程处理困难的方式，设计了 WPF （窗口演示文稿基金会）。这篇文章可以帮助理解线程在 WPF 中的正确用法。

WPF 内部线程和规则

所有 WPF 应用程序中都运行两个线程：

1. 为呈现-它在后台运行，所以，它被隐藏。
2. 用于管理 UI 界面 （UI 线程） — —

大多数 WPF 对象与 UI 线程被束缚。它接收输入、 绘制屏幕、 运行的代码和处理事件。

WPF 支持单线程单元模型，有以下规则：

1. 一个线程在整个应用程序中运行，并拥有所有 WPF 对象。
2. WPF 元素有其他线程不能彼此交互的线程亲和手段。
3. 具有线程关联的 WPF 对象从调度程序对象派生。

线程处理在 WPF 中由开发商

而在 WPF 开发人员都需要如此管理线程在某些情况下创建应用程序，它提供了一些方法来处理，并在不同的场景上的应用程序中使用的线程。以下是为处理线程的两种方式：

1. 调度程序
2. 后台辅助线程。

调度程序

调度程序是System.Windows.Threading 的一个实例。调度员类。它拥有应用程序线程和管理队列的工作项。它的每个优先，以执行 UI 操作以 fifo （先进先出） 的方式。它并不创建新的线程。它不是多线程的。

每个视觉 WPF 对象从DispatcherObject派生。它是一个链接到 DispatcherObject 类的对象。以下是 DispatcherObject 类的成员：

(1) 属性

1. 调度员： 它获取调度程序。

(2) 方法：

在 DispatcherObject Class 中有几种方法。一些重要的方法如下:

1. Checkaccess 方法 ()： 它返回 true，则代码是一个正确的线程使用的对象。
2. VerifyAccess ()： 如果是没有的代码是在使用对象否则为会引发与"能反转"正确的线程上。
3. GetType ()： 它获取当前实例的类型。

WPF 对象调用VerifyAccess () 频繁地项目本身。

我们为什么需要调度程序？

将澄清的调度员在 WPF 应用程序中需要一个例子：

 using System;
 using System.Threading;
 using System.Windows;

 namespace WpfApplication1
 {
    /// <summary>
    /// Interaction logic for WPF UI Upadation using
    /// thread.
 /// </summary>

    public partial class MainWindow : Window
     {

        public MainWindow()
         {
            InitializeComponent();
         }

         private void MyButton_Click(object sender, RoutedEventArgs e)
          {
             Thread thread = new Thread(UpdateText);
             thread.Start();
          }

       private void UpdateText()
         {
             Thread.Sleep(TimeSpan.FromSeconds());
             TxtName.Text = "Hello Geeks !";
         }
      }
 }

现在，这是一个错误的代码，因为将会在一个新线程，执行UpdateText()的方法，不允许线程访问 WPF 对象。

"VerifyAccess()"方法调用和不能被"加载"。

以上代码的校正：

 using System;
 using System.Threading;
 using System.Windows;

 namespace WpfApplication1
 {
     /// <summary>
     /// Interaction logic for WPF UI Upadation using
     /// Dispatcher.
     /// </summary>

     public partial class MainWindow : Window
      {
         public MainWindow()
          {

             InitializeComponent();
          }

         private void MyButton_Click(object sender, RoutedEventArgs e)
          {

             Thread thread = new Thread(UpdateText);
             thread.Start();
          }

         private void UpdateText()
      {
          Thread.Sleep(TimeSpan.FromSeconds());
          this.Dispatcher.BeginInvoke(new Action(() =>
         {
            TxtName.Text = "Hello Geeks !";
         }));
     }
       }
 }

所以，调度程序是与线程更新 WPF 用户界面的最佳途径。

后台辅助线程

它是非常有利的耗时的任务。它在同一时间执行的代码。它是在一个单独的线程中调用。它会自动与应用程序的主线程进行同步。

它用来在后台运行操作和延迟到 UI 的执行。以下是某些情况下可以使用后台辅助线程的场合：

1. 如果用户想要在特定的操作响应 UI 和面孔延误。
2. 数据下载。
3. 数据库事务。

BackgroundWorker 是在System.ComponentModel下的类。它将执行一个单独的线程上运行。

 using System;
 using System.ComponentModel;
 using System.Threading;

 namespace BackGroundWorkerExample
 {

     /// <summary>
     /// It implements backgroundworker.
     /// </summary>

     class Program
      {

         private static BackgroundWorker backgroundWorker;
         static void Main(string[] args)
           {
              backgroundWorker = new BackgroundWorker
           {
             WorkerReportsProgress = true,
             WorkerSupportsCancellation = true
         };

             //Event creation.

             //For the performing operation in the background.

             backgroundWorker.DoWork += backgroundWorker_DoWork;

             //For the display of operation progress to UI.

             backgroundWorker.ProgressChanged += backgroundWorker_ProgressChanged;

             //After the completation of operation.

             backgroundWorker.RunWorkerCompleted += backgroundWorker_RunWorkerCompleted;

             backgroundWorker.RunWorkerAsync("Press Enter in the next 5 seconds to Cancel operation:");

             Console.ReadLine();

             if (backgroundWorker.IsBusy)
         {
             backgroundWorker.CancelAsync();
            Console.ReadLine();
         }
 }

现在，在背景中执行操作。

 /// <summary>
 /// Performs operation in the background.
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>

 static void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
   {

     for (int i = ; i < ; i++)
        {
         if (backgroundWorker.CancellationPending)
            {
             e.Cancel = true;
             return;
                }

                backgroundWorker.ReportProgress(i);
            Thread.Sleep();
            e.Result = ;
            }
 }

为执行操作进度的更改事件。

 /// <summary>
 /// Displays Progress changes to UI .
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>

 static void backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
 {
     Console.WriteLine("Completed" + e.ProgressPercentage + "%");
 }

通过使用 Runworker 完成事件显示结果：

 1 /// <summary>
 2 /// Displays result of background performing operation.
 3 /// </summary>
 4 /// <param name="sender"></param>
 5 /// <param name="e"></param>
 6
 7 static void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
 8   {
 9     if (e.Cancelled)
10        {
11             Console.WriteLine("Operation Cancelled");
12            }
13     else if (e.Error != null)
14        {
15             Console.WriteLine("Error in Process :" + e.Error);
16        }
17      else
18        {
19                 Console.WriteLine("Operation Completed :" + e.Result);
20        }
21
22   }

输出：

已完成的 0%

已完成的 1%

已完成的 2%

..........................

调度程序和后台辅助线程之间的区别：

1. 后台辅助线程执行的代码在同一时间在一个单独的线程中调用它。调度程序处理的事情要做每一次队列时，它可自动同步和 WPF 应用程序的主线程。
2. 后台辅助线程在单独的线程中执行与 WPF 应用程序的 UI 线程调度程序运行的同时。
3. 如果你想要在后台运行操作，向用户界面，使用一个后台工作人员但使用调度程序封送回对 WPF UI 的更新。