====== Processing Form Template ======

<code c#>
using System;
using System.Diagnostics;
using System.Globalization;
using System.Threading;
using System.Windows.Forms;

public partial class ProcessingFormTemplate : Form
{
	private const string StartButtonText = "Start";
	private const string StopButtonText = "Stop";

	private Processor _processor;
	private Processor Processor
	{
		get
		{
			if (_processor == null)
			{
				_processor = new Processor();
				_processor.LogMessageEvent += new EventHandler<LogMessageEventArgs>(Processor_LogMessage);
				_processor.ProcessingCompleteEvent += new EventHandler(Processor_ProcessingComplete);
			}

			return _processor;
		}
	}

	public ProcessingFormTemplate()
	{
		InitializeComponent();
	}

	private void buttonStartStopProcessing_Click(object sender, EventArgs e)
	{
		Debug.Assert(sender == buttonStartStopProcessing, "Incorrect object triggered a click event.");

		switch (buttonStartStopProcessing.Text)
		{
			case StartButtonText:
				UpdateUIForStartStopProcessing(true);
				StartProcessing();
				break;

			case StopButtonText:
				UpdateUIForStartStopProcessing(false);
				StopProcessing();
				break;

			default:
				Debug.Assert(true, "The object buttonStart has invalid Text.");

				// Ignore the click.
				break;
		}
	}

	private void StopProcessing()
	{
		Processor.StopProcessing();
	}

	private void StartProcessing()
	{
		ProcessorOptions processorOptions = GetCurrentOptions();

		Processor.StartProcessing(processorOptions);
	}

	private ProcessorOptions GetCurrentOptions()
	{
		ProcessorOptions processorOptions = new ProcessorOptions();

		processorOptions.SomeOption = checkBoxSomeOption.Checked;

		return processorOptions;
	}

	private delegate void UpdateUIForStartStopProcessingCallback(bool IsProcessing);
	private void UpdateUIForStartStopProcessing(bool IsProcessing)
	{
		if (this.buttonStartStopProcessing.InvokeRequired || this.checkBoxSomeOption.InvokeRequired)
		{
			UpdateUIForStartStopProcessingCallback callback = new UpdateUIForStartStopProcessingCallback(UpdateUIForStartStopProcessing);
			this.Invoke(callback, new object[] { IsProcessing });
		}
		else
		{
			foreach (Control control in this.Controls)
			{
				if (control != buttonStartStopProcessing)
					control.Enabled = !IsProcessing;
			}

			buttonStartStopProcessing.Text = IsProcessing ? StopButtonText : StartButtonText;
		}
	}

	private void Processor_ProcessingComplete(object sender, EventArgs e)
	{
		UpdateUIForStartStopProcessing(false);
	}

	private void Processor_LogMessage(object sender, LogMessageEventArgs e)
	{
		LogMessage(e.Message);
	}

	private delegate void LogMessageCallback(string message);
	private void LogMessage(string message)
	{
#if DEBUG
		string timeFormat = "hh:mm:ss.fff ";
#else
		string timeFormat = "hh:mm:ss ";
#endif

		if (this.textBoxMessageLog.InvokeRequired)
		{
			LogMessageCallback callback = new LogMessageCallback(LogMessage);
			this.Invoke(callback, new object[] { message });
		}
		else
		{
			StringBuilder fullMessage = new StringBuilder();
			fullMessage.Append(DateTime.Now.ToShortDateString());
			fullMessage.Append(" ");
			fullMessage.Append(DateTime.Now.ToString(timeFormat, CultureInfo.CurrentCulture));
			fullMessage.Append(message);
			fullMessage.Append(Environment.NewLine);

			this.textBoxMessageLog.AppendText(fullMessage.ToString());
		}
	}
}

public class LogMessageEventArgs : EventArgs
{
	public string Message { get; set; }
}

public class ProcessorOptions
{
	public bool SomeOption { get; set; }
}

public class Processor
{
	public event EventHandler<LogMessageEventArgs> LogMessageEvent;
	public event EventHandler ProcessingCompleteEvent;

	private bool PleaseStopProcessing;

	private ProcessorOptions Options;

	public Processor()
	{
	}

	public void StartProcessing(ProcessorOptions processorOptions)
	{
		this.Options = processorOptions;

		PleaseStopProcessing = false;

		new Thread(new ThreadStart(StartProcessingAsync)).Start();
	}

	public void StopProcessing()
	{
		PleaseStopProcessing = true;
	}

	private void StartProcessingAsync()
	{
		OnLogMessageEvent("Processing starting.");

		Thread.Sleep(1000);
		if (this.PleaseStopProcessing)
		{
			StopProcessing(true);
			return;
		}

		OnLogMessageEvent(this.Options.SomeOption ? "Some option was selected." : "Some option was not selected.");

		Thread.Sleep(1000);
		if (this.PleaseStopProcessing)
		{
			StopProcessing(true);
			return;
		}

		OnLogMessageEvent("Still going...");

		Thread.Sleep(1000);
		if (this.PleaseStopProcessing)
		{
			StopProcessing(true);
			return;
		}

		OnLogMessageEvent("Nearly there...");

		Thread.Sleep(1000);
		if (this.PleaseStopProcessing)
		{
			StopProcessing(true);
			return;
		}

		StopProcessing(false);
	}

	private void StopProcessing(bool WasProcessingInterupted)
	{
		OnLogMessageEvent(WasProcessingInterupted ? "Processing interrupted." : "Processing completed.");
		OnProcessingCompleteEvent();			
	}

	protected virtual void OnLogMessageEvent(string message)
	{
		LogMessageEvent(this, new LogMessageEventArgs() { Message = message });
	}

	protected virtual void OnProcessingCompleteEvent()
	{
		ProcessingCompleteEvent(this, new EventArgs());
	}
}
</code>

{{tag>code_snippet c_sharp processing processor win_form}}