BackgroundWorker study

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Threading;
namespace Backgroundworkerdemo
{
    public partial class Form1 : Form
    {
        /// <summary>
        /// 本实例演示如何在关闭窗体的时候取消Backgroundworker中正在运行的任务
        /// </summary>
        public Form1()
        {
            InitializeComponent();
            backgroundWorker1.WorkerSupportsCancellation = true;
            backgroundWorker1.DoWork += backgroundWorker1_DoWork;
            backgroundWorker1.RunWorkerCompleted += backgroundWorker1_RunWorkerCompleted;
        }

        void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            Console.WriteLine("Completed");
            this.Close();//throw new NotImplementedException();
        }
        protected override void OnClosing(CancelEventArgs e)
        {
            backgroundWorker1.CancelAsync();
            //如果还有任务在处理，取消关闭窗口，在任务处理完毕后再关闭
            if (backgroundWorker1.IsBusy)
            {
                e.Cancel = true;
            }
            else
                base.OnClosing(e);
        }
        private void Form1_Load(object sender, EventArgs e)
        {
            backgroundWorker1.RunWorkerAsync();
        }

        void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
        {
            //检查是否已经发起取消操作
            while (!backgroundWorker1.CancellationPending)
            {
                Thread.Sleep(1000);
                Console.WriteLine(DateTime.Now);
            }
            //throw new NotImplementedException();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            this.Close();
        }
    }
}

　　

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

using System.Xml;
using System.Threading;

namespace BackgroundWorkerDownload
{
	public partial class Form1 : Form
	{
		public Form1()
		{
			InitializeComponent();

			backgroundWorker1.DoWork += BackgroundWorker1_DoWork;
			backgroundWorker1.RunWorkerCompleted += BackgroundWorker1_RunWorkerCompleted;
		}

		private XmlDocument document = null;

		private void BackgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
		{
			// Set progress bar to 100% in case it's not already there.
			progressBar1.Value = 100;

			if (e.Error == null)
			{
				MessageBox.Show(document.InnerXml, "下載完成");
			}
			else
			{
				MessageBox.Show("無法下載檔案，下載失敗", "下載檔案", MessageBoxButtons.OK, MessageBoxIcon.Error);
			}

			// Enable the download button and reset the progress bar.
			btnDownload.Enabled = true;
			progressBar1.Value = 0;
		}

		private void BackgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
		{
			document = new XmlDocument();

			Thread.Sleep(10000);

			// Replace this file name with a valid file name.
			document.Load(@"http://www.tailspintoys.com/sample.xml");
		}

		private void Form1_Load(object sender, EventArgs e)
		{

		}

		private void btnDownload_Click(object sender, EventArgs e)
		{
			// Start the download operation in the background.
			backgroundWorker1.RunWorkerAsync();

			// Disable the button for the duration of the download.
			btnDownload.Enabled = false;

			// Once you have started the background thread you
			// can exit the handler and the application will
			// wait until the RunWorkerCompleted event is raised.

			// Or if you want to do something else in the main thread,
			// such as update a progress bar, you can do so in a loop
			// while checking IsBusy to see if the background task is
			// still running.
			while (this.backgroundWorker1.IsBusy)
			{
				progressBar1.Increment(1);
				// Keep UI messages moving, so the form remains
				// responsive during the asynchronous operation.
				Application.DoEvents();
				// 避免 CPU 飆高
				Thread.Sleep(1);
			}
		}
	}
}

　　

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

using System.Threading;

namespace BackgroundWorkerSimple
{
	public partial class Form1 : Form
	{
		public Form1()
		{
			InitializeComponent();
			backgroundWorker1.WorkerReportsProgress = true;
			backgroundWorker1.WorkerSupportsCancellation = true;
		}

		private void Form1_Load(object sender, EventArgs e)
		{
			backgroundWorker1.DoWork += BackgroundWorker1_DoWork;
			backgroundWorker1.ProgressChanged += BackgroundWorker1_ProgressChanged;
			backgroundWorker1.RunWorkerCompleted += BackgroundWorker1_RunWorkerCompleted;
		}

		private void BackgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
		{
			if (e.Cancelled == true)
				lblResult.Text = "取消";
			else if (e.Error != null)
				lblResult.Text = "錯誤訊息： " + e.Error.Message;
			else
				lblResult.Text = "完成";
		}

		private void BackgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
		{
			lblResult.Text = $"已完成進度：{e.ProgressPercentage}%";
		}

		private void BackgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
		{
			BackgroundWorker worker = sender as BackgroundWorker;

			for (int i = 1; i <= 10; i++)
			{
				if (worker.CancellationPending == true)
				{
					e.Cancel = true;
					break;
				}

				// Perform a time consuming operation and report progress.
				Thread.Sleep(500);
				worker.ReportProgress(i * 10);
			}
		}

		private void btnStartAsync_Click(object sender, EventArgs e)
		{
			if (backgroundWorker1.IsBusy == true) return;
			// Start the asynchronous operation.
			backgroundWorker1.RunWorkerAsync();
		}

		private void btnCancelAsync_Click(object sender, EventArgs e)
		{
			// WorkerSupportsCancellation 屬性為 true，才可以執行 CancelAsync method
			if (backgroundWorker1.WorkerSupportsCancellation == false) return;
			// Cancel the asynchronous operation.
			backgroundWorker1.CancelAsync();
		}
	}
}

　　

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

using System.IO;

namespace WalkthroughBackgroundWorker
{
	public partial class Form1 : Form
	{
		public Form1()
		{
			InitializeComponent();
		}
		private void Form1_Load(object sender, EventArgs e)
		{
			// 屬性設定
			// 使用 ReportProgress() 必須把 WorkerReportsProgress 設為 true
			backgroundWorker1.WorkerReportsProgress = true;
			backgroundWorker1.WorkerSupportsCancellation = true;

			// 事件註冊
			backgroundWorker1.RunWorkerCompleted += BackgroundWorker1_RunWorkerCompleted;
			backgroundWorker1.ProgressChanged += BackgroundWorker1_ProgressChanged;
			backgroundWorker1.DoWork += BackgroundWorker1_DoWork;

			txtSourceFile.Text = @"D:\Sample.txt";
			txtCompareString.Text = "21934";
			CounterReset();
			ButtonControl(true);
		}
		private void StartThread()
		{
			CounterReset();

			Words WC = new Words();
			WC.SourceFile = txtSourceFile.Text.Trim();
			WC.CompareString = txtCompareString.Text.Trim();

			// RunWorkerAsync() 會觸發 DoWork Event
			backgroundWorker1.RunWorkerAsync(WC);
		}
		private void BackgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
		{
			// This event handler is where the actual work is done.
			// This method runs on the background thread.
			BackgroundWorker worker = (BackgroundWorker)sender;
			Words WC = (Words)e.Argument;
			WC.CountWords(worker, e);
		}
		private void BackgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
		{
			// This method runs on the main thread.
			// 更新統計資訊
			Words.CurrentState state =
				(Words.CurrentState)e.UserState;
			txtLinesCounted.Text = state.LinesCounted.ToString();
			txtWordsCounted.Text = state.WordsMatched.ToString();
		}
		private void BackgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
		{
			// This event handler is called when the background thread finishes.
			// This method runs on the main thread.
			if (e.Error != null)
				MessageBox.Show("錯誤訊息：" + e.Error.Message);
			else if (e.Cancelled)
				MessageBox.Show("字數統計取消");
			else
				MessageBox.Show("完成字數統計");

			ButtonControl(true);
		}
		private void btnStart_Click(object sender, EventArgs e)
		{
			if (File.Exists(txtSourceFile.Text.Trim()) == false)
			{
				MessageBox.Show("該檔案路徑不存在，無法進行解析", "錯誤", MessageBoxButtons.OK, MessageBoxIcon.Error);
				return;
			}

			ButtonControl(false);
			StartThread();
		}
		private void btnCancel_Click(object sender, EventArgs e)
		{
			// 取消非同步操作
			backgroundWorker1.CancelAsync();
			CounterReset();
			ButtonControl(true);
		}
		private void ButtonControl(bool state)
		{
			btnStart.Enabled = state;
			btnCancel.Enabled = !state;
		}
		private void CounterReset()
		{
			txtWordsCounted.Text = "0";
			txtLinesCounted.Text = "0";
		}
		private void btnFileSelect_Click(object sender, EventArgs e)
		{
			OpenFileDialog fd = new OpenFileDialog();
			fd.Filter = "txt 檔案 (*.*)|*.txt";
			fd.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
			if (fd.ShowDialog() == DialogResult.Cancel) return;
			txtSourceFile.Text = fd.FileName;
		}
	}
}

　　

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using System.Text.RegularExpressions;
using System.ComponentModel;
using System.IO;
using System.Threading;

namespace WalkthroughBackgroundWorker
{
	public class Words
	{
		// Object to store the current state, for passing to the caller.
		public class CurrentState
		{
			public int LinesCounted { get; set; }
			public int WordsMatched { get; set; }
		}

		public string SourceFile { get; set; }
		public string CompareString { get; set; }
		private int WordCount { get; set; }
		private int LinesCounted { get; set; }

		public void CountWords(BackgroundWorker worker, DoWorkEventArgs e)
		{
			if (string.IsNullOrEmpty(CompareString))
				throw new Exception("沒有指定搜尋字串");

			// 變數初始化
			CurrentState state = new CurrentState();
			string line = string.Empty;
			// int elapsedTime = 20;
			// DateTime lastReportDateTime = DateTime.Now;

			// 利用 StreamReader 讀取 txt 檔案
			using (StreamReader sr = new StreamReader(SourceFile))
			{
				// Process lines while there are lines remaining in the file.
				while (!sr.EndOfStream)
				{
					// 使用者取消後，就不繼續讀取
					if (worker.CancellationPending == true)
					{
						e.Cancel = true;
						break;
					}

					line = sr.ReadLine();
					WordCount += CountInString(line, CompareString);
					// 紀錄行數
					LinesCounted++;

					// Raise an event so the form can monitor progress.
					// 每 20 毫秒才透過 ReportProgress() 觸發 ProgressChanged Event，避免觸發太過頻繁
					//int compare = DateTime.Compare(
					//	DateTime.Now,
					//	lastReportDateTime.AddMilliseconds(elapsedTime));
					//if (compare < 0) continue;

					state.LinesCounted = LinesCounted;
					state.WordsMatched = WordCount;
					worker.ReportProgress(0, state);
					// 重置 lastReportDateTime 變數
					// lastReportDateTime = DateTime.Now;
					// 處理每一行都停止 50 毫秒，方便觀察執行結果
					Thread.Sleep(50);
				}

				// Report the final count values.
				state.LinesCounted = LinesCounted;
				state.WordsMatched = WordCount;
				worker.ReportProgress(100, state);
			}
		}

		private int CountInString(string SourceString, string CompareString)
		{
			// This function counts the number of times
			// a word is found in a line.
			if (SourceString == null)
			{
				return 0;
			}

			// Regex.Escape：以逸出碼取代 (\、*、+、?、|、{、[、(、)、^、$、.、# 和泛空白字元) 等字元。 這樣會指示規則運算式引擎將這些字元解譯為常值，而非解譯為中繼字元。
			string EscapedCompareString = Regex.Escape(CompareString);

			// To count all occurrences of the string, even within words, remove both instances of @"\b" from the following line.
			// 下述兩種寫法都可以使用
			string pattern = @"\b" + EscapedCompareString + @"\b";
			// string pattern = $"\\b{EscapedCompareString}\\b";

			Regex regex = new Regex(pattern, RegexOptions.IgnoreCase);
			MatchCollection matches = regex.Matches(SourceString);
			return matches.Count;
		}
	}
}