在 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(5));
            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(5));
         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 = 0; i < 200; i++)
       {
        if (backgroundWorker.CancellationPending)
           {
            e.Cancel = true;
            return;
               }

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

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

/// <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 的更新。