A common class for executing tasks with a responsive UI

            using (ThreadedExecuter<void> executer = new ThreadedExecuter<void>(this))
            {
                executer
                    .Process(() =>
                    {
                        foo();
                    })
                    .WhenFinished(null =>
                    {
                        foofoo(); 
                    })
                    .Run();
            }
</void></void>

using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel;
 
namespace Library
{
	// Void
	//using (ThreadedExecuter executer = new ThreadedExecuter(this))
	//{
	//    executer
	//        .Process(() =>
	//        {
	//            int asdfa = 0;

	//        })
	//        .WhenFinished(() =>
	//            {
	//                this.Text = "";
	//            }
	//        )
	//        .Run();
	//}

	// Int/String //enige object
	//using (ThreadedExecuter<int> worker = new ThreadedExecuter<int>(view))
	//{
	//    worker
	//         .Process(() =>
	//         {
	//             Thread.Sleep(1000);
	//             return 42;
	//         })
	//         .WhenFinished(workerResult =>
	//         {
	//             int i = workerResult;

	//         })
	//    .Run();
	//}
	public interface IThreadedExecuterView
	{
		void SetWait(bool isEnabled);
		void HandleException(Exception ex);
	}
	public delegate void ThreadedExecuterDelegate();
	public class ThreadedExecuter : IDisposable
	{
		public ThreadedExecuter()
		{
		}
 
		public ThreadedExecuter(IThreadedExecuterView View)
		{
			this.View = View;
		}
 
		BackgroundWorker worker = null;
		IThreadedExecuterView View = null;
 
		//for value types use default instead of null since won't be valid when casting, will alows us to use int, etc. in addition to classes

 
		public ThreadedExecuter Process(ThreadedExecuterDelegate GetResultsAction)
		{
			View.SetWait(false);
 
			worker = new BackgroundWorker();
 
			worker.DoWork += new DoWorkEventHandler(delegate(object sender, DoWorkEventArgs e)
			{
				try
				{
					GetResultsAction();
				}
				catch (Exception ex)
				{
					View.HandleException(ex);
				}
			});
 
			return this;
		}
 
		public ThreadedExecuter WhenFinished(Action ProcessResultsAction)
		{
			worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(delegate(object sender, RunWorkerCompletedEventArgs e)
			{
				//if any end action and want to continue, call it
				//want the results action to continue to wait until done
				//but want post action to not be within wait
				try
				{
					ProcessResultsAction();
				}
				finally
				{
					//don't ever want to allow this to get an exception so we can get endinvoke exception
					//want to make sure we stop from waiting, even on error
					try
					{
						View.SetWait(true);
					}
					catch (Exception ex)
					{
						Console.WriteLine("Error setting view wait: " + ex.ToString());
					}
				}
			});
			return this;
		}
 
		Action FinallyDelegate = null;
 
		public ThreadedExecuter Finally(Action FinallyDelegate)
		{
			this.FinallyDelegate = FinallyDelegate;
			return this;
		}
 
		public ThreadedExecuter Run()
		{
			//callpost action if any
			if (FinallyDelegate != null)
			{
				worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(delegate(object sender, RunWorkerCompletedEventArgs e)
				{
					try
					{
						FinallyDelegate();
					}
					catch (Exception ex)
					{
						View.HandleException(ex);
					}
				});
			}
 
			worker.RunWorkerAsync();
 
			return this;
		}
 
		public void Dispose()
		{
			if (worker != null)
				worker.Dispose();
		}
 
	}
 

 
	public delegate T ThreadedExecuterDelegate<T>();
 
	/// <summary>
	/// Class to encapsulate frequently needed action in background thread with hourglass and disabled form,
	/// then use results frombackground thread, then do something immediately after
	/// </summary>
	/// <typeparam name="T"></typeparam>
	public class ThreadedExecuter<T> : IDisposable
	{
		public ThreadedExecuter()
		{
		}
 
		public ThreadedExecuter(IThreadedExecuterView View)
		{
			this.View = View;
		}
 
		BackgroundWorker worker = null;
		IThreadedExecuterView View = null;
 
		//for value types use default instead of null since won't be valid when casting, will alows us to use int, etc. in addition to classes
		T actionValue = default(T);
 
		public ThreadedExecuter<T> Process(ThreadedExecuterDelegate<T> GetResultsAction)
		{
			View.SetWait(false);
 
			worker = new BackgroundWorker();
 
			worker.DoWork += new DoWorkEventHandler(delegate(object sender, DoWorkEventArgs e)
			{
				try
				{
					e.Result = GetResultsAction();
				}
				catch (Exception ex)
				{
					View.HandleException(ex);
				}
			});
 
			return this;
		}
 
		public ThreadedExecuter<T> WhenFinished(Action<T> ProcessResultsAction)
		{
			worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(delegate(object sender, RunWorkerCompletedEventArgs e)
			{
				if (e != null && e.Result != null)
					actionValue = (T)e.Result;
 
				//if any end action and want to continue, call it
				//want the results action to continue to wait until done
				//but want post action to not be within wait
				try
				{
					ProcessResultsAction(actionValue);
				}
				finally
				{
					//don't ever want to allow this to get an exception so we can get endinvoke exception
					//want to make sure we stop from waiting, even on error
					try
					{
						View.SetWait(true);
					}
					catch (Exception ex)
					{
						Console.WriteLine("Error setting view wait: " + ex.ToString());
					}
				}
			});
 
			return this;
		}
 
		Action FinallyDelegate = null;
 
		public ThreadedExecuter<T> Finally(Action FinallyDelegate)
		{
			this.FinallyDelegate = FinallyDelegate;
			return this;
		}
 
		public ThreadedExecuter<T> Run()
		{
			//callpost action if any
			if (FinallyDelegate != null)
			{
				worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(delegate(object sender, RunWorkerCompletedEventArgs e)
				{
					try
					{
						FinallyDelegate();
					}
					catch (Exception ex)
					{
						View.HandleException(ex);
					}
				});
			}
 
			worker.RunWorkerAsync();
 
			return this;
		}
 
		public void Dispose()
		{
			if (worker != null)
				worker.Dispose();
		}
 
	}
 
}

using (ThreadedExecuter executer = new ThreadedExecuter(this))
            {
				executer
					.Process(() =>
					{
						int asdfa = 0;
 
					})
					.WhenFinished(() =>
						{
							this.Text = "";
						}
					)
					.Run();
            }

using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel;
 
namespace Library
{
	// Void
	//using (ThreadedExecuter executer = new ThreadedExecuter(this))
	//{
	//    executer
	//        .Process(() =>
	//        {
	//            int asdfa = 0;

	//        })
	//        .WhenFinished(() =>
	//            {
	//                this.Text = "";
	//            }
	//        )
	//        .Run();
	//}

	// Int/String //enige object
	//using (ThreadedExecuter<int> worker = new ThreadedExecuter<int>(view))
	//{
	//    worker
	//         .Process(() =>
	//         {
	//             Thread.Sleep(1000);
	//             return 42;
	//         })
	//         .WhenFinished(workerResult =>
	//         {
	//             int i = workerResult;

	//         })
	//    .Run();
	//}
	public interface IThreadedExecuterView
	{
		void SetWait(bool isEnabled);
		void HandleException(Exception ex);
	}
	public delegate void ThreadedExecuterDelegate();
	public class ThreadedExecuter : IDisposable
	{
		public ThreadedExecuter()
		{
		}
 
		public ThreadedExecuter(IThreadedExecuterView View)
		{
			this.View = View;
		}
 
		BackgroundWorker worker = null;
		IThreadedExecuterView View = null;
 
		//for value types use default instead of null since won't be valid when casting, will alows us to use int, etc. in addition to classes

 
		public ThreadedExecuter Process(ThreadedExecuterDelegate GetResultsAction)
		{
			View.SetWait(false);
 
			worker = new BackgroundWorker();
 
			worker.DoWork += new DoWorkEventHandler(delegate(object sender, DoWorkEventArgs e)
			{
				try
				{
					GetResultsAction();
				}
				catch (Exception ex)
				{
					View.HandleException(ex);
				}
			});
 
			return this;
		}
 
		public ThreadedExecuter WhenFinished(Action ProcessResultsAction)
		{
			worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(delegate(object sender, RunWorkerCompletedEventArgs e)
			{
				//if any end action and want to continue, call it
				//want the results action to continue to wait until done
				//but want post action to not be within wait
				try
				{
					ProcessResultsAction();
				}
				finally
				{
					//don't ever want to allow this to get an exception so we can get endinvoke exception
					//want to make sure we stop from waiting, even on error
					try
					{
						View.SetWait(true);
					}
					catch (Exception ex)
					{
						Console.WriteLine("Error setting view wait: " + ex.ToString());
					}
				}
			});
			return this;
		}
 
		Action FinallyDelegate = null;
 
		public ThreadedExecuter Finally(Action FinallyDelegate)
		{
			this.FinallyDelegate = FinallyDelegate;
			return this;
		}
 
		public ThreadedExecuter Run()
		{
			//callpost action if any
			if (FinallyDelegate != null)
			{
				worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(delegate(object sender, RunWorkerCompletedEventArgs e)
				{
					try
					{
						FinallyDelegate();
					}
					catch (Exception ex)
					{
						View.HandleException(ex);
					}
				});
			}
 
			worker.RunWorkerAsync();
 
			return this;
		}
 
		public void Dispose()
		{
			if (worker != null)
				worker.Dispose();
		}
 
	}
 

 
	public delegate T ThreadedExecuterDelegate<T>();
 
	/// <summary>
	/// Class to encapsulate frequently needed action in background thread with hourglass and disabled form,
	/// then use results frombackground thread, then do something immediately after
	/// </summary>
	/// <typeparam name="T"></typeparam>
	public class ThreadedExecuter<T> : IDisposable
	{
		public ThreadedExecuter()
		{
		}
 
		public ThreadedExecuter(IThreadedExecuterView View)
		{
			this.View = View;
		}
 
		BackgroundWorker worker = null;
		IThreadedExecuterView View = null;
 
		//for value types use default instead of null since won't be valid when casting, will alows us to use int, etc. in addition to classes
		T actionValue = default(T);
 
		public ThreadedExecuter<T> Process(ThreadedExecuterDelegate<T> GetResultsAction)
		{
			View.SetWait(false);
 
			worker = new BackgroundWorker();
 
			worker.DoWork += new DoWorkEventHandler(delegate(object sender, DoWorkEventArgs e)
			{
				try
				{
					e.Result = GetResultsAction();
				}
				catch (Exception ex)
				{
					View.HandleException(ex);
				}
			});
 
			return this;
		}
 
		public ThreadedExecuter<T> WhenFinished(Action<T> ProcessResultsAction)
		{
			worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(delegate(object sender, RunWorkerCompletedEventArgs e)
			{
				if (e != null && e.Result != null)
					actionValue = (T)e.Result;
 
				//if any end action and want to continue, call it
				//want the results action to continue to wait until done
				//but want post action to not be within wait
				try
				{
					ProcessResultsAction(actionValue);
				}
				finally
				{
					//don't ever want to allow this to get an exception so we can get endinvoke exception
					//want to make sure we stop from waiting, even on error
					try
					{
						View.SetWait(true);
					}
					catch (Exception ex)
					{
						Console.WriteLine("Error setting view wait: " + ex.ToString());
					}
				}
			});
 
			return this;
		}
 
		Action FinallyDelegate = null;
 
		public ThreadedExecuter<T> Finally(Action FinallyDelegate)
		{
			this.FinallyDelegate = FinallyDelegate;
			return this;
		}
 
		public ThreadedExecuter<T> Run()
		{
			//callpost action if any
			if (FinallyDelegate != null)
			{
				worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(delegate(object sender, RunWorkerCompletedEventArgs e)
				{
					try
					{
						FinallyDelegate();
					}
					catch (Exception ex)
					{
						View.HandleException(ex);
					}
				});
			}
 
			worker.RunWorkerAsync();
 
			return this;
		}
 
		public void Dispose()
		{
			if (worker != null)
				worker.Dispose();
		}
 
	}
 
}

//------------------------------------------------------------------------------
// <copyright 
//  file="ThreadedExecuter.cs" 
//  version="1.0">
// </copyright>
//
// <author></author>
//------------------------------------------------------------------------------
namespace Library
{
    using System;
    using System.Collections.Generic;
    using System.Text;
    using System.ComponentModel;
 
    /// <summary>
    /// This class provides a background thread executer
    /// </summary>
    /// <example>
    /// using (ThreadedExecuter executer = new ThreadedExecuter(this))
    /// {
    ///     executer
    ///         .Process(() =>
    ///         {
    ///             int foo = 0;
    ///         })
    ///         .WhenFinished(() =>
    ///             {
    ///                 this.uxFoo.Text = "";
    ///             }
    ///         )
    ///         .Run();
    /// }
    /// </example> 
    public class ThreadedExecuter : IDisposable
    {
        #region Fields
        // The background worker for ThreadedExecuter class
        private BackgroundWorker worker;
 
        // 
        private IThreadedExecuterView view;
 
        //
        private Action finallyDelegate;
 
        // Indicates if this object is disposed or not
        private bool disposed;
        #endregion
 
        #region Constructor
        /// <summary>
        /// Initializes a new instance of the <see cref="ThreadedExecuter"/> class.
        /// </summary>
        public ThreadedExecuter()
        {
        }
 
        /// <summary>
        /// Initializes a new instance of the <see cref="ThreadedExecuter"/> class.
        /// </summary>
        /// <param name="View"></param>
        public ThreadedExecuter(IThreadedExecuterView view)
        {
            this.view = view;
        }
        #endregion
 
        #region Destructor
        /// <summary>
        /// Finalizes an instance of the <see cref="ThreadedExecuter"/> class
        /// </summary>
        ~ThreadedExecuter()
        {
            Dispose(false);
        }
 
        /// <summary>
        /// Dispose <see cref="ThreadedExecuter"/>
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
 
            // Tell the garbage collector not to call the finalizer
            // since all the cleanup will already be done.
            GC.SuppressFinalize(true);
        }
 
        /// <summary>
        /// Disposes managed and unmanaged resources for the <see cref="ThreadedExecuter"/>
        /// </summary>
        /// <param name="disposing">Dispose managed resources or not</param>
        private void Dispose(bool disposing)
         {
             if (this.disposed)
             {
                 return;
             }
 
             if (disposing)
             {
                 // Free any managed resources in this section
                 if (worker != null)
                 {
                     worker.Dispose();
                 }
             }
 
             // Free any unmanaged resources in this section
             this.disposed = true;
         }
        #endregion
 
        #region Methods
        /// <summary>
        /// This method handel's the code the needs to be processed in the background thread.   
        /// </summary>
        /// <remarks>
        /// For value types use default instead of null, since null won't be valid when casting
        /// </remarks>
        /// <param name="GetResultsAction"></param>
        /// <returns></returns>
        public ThreadedExecuter Process(ThreadedExecuterDelegate GetResultsAction)
        {
            view.SetWait(false);
 
            worker = new BackgroundWorker();
 
            worker.DoWork += new DoWorkEventHandler(delegate(object sender, DoWorkEventArgs e)
            {
                try
                {
                    GetResultsAction();
                }
                catch (Exception ex)
                {
                    view.HandleException(ex);
                }
            });
 
            return this;
        }
 
        /// <summary>
        /// Provides a way to execute actions after the thread has finished 
        /// </summary>
        /// <param name="ProcessResultsAction"></param>
        /// <returns>The thread executer object</returns>
        public ThreadedExecuter WhenFinished(Action ProcessResultsAction)
        {
            worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(delegate(object sender, RunWorkerCompletedEventArgs e)
            {
                // If any end action and want to continue, call it
                // want the results action to continue to wait until done
                // but want post action to not be within wait
                try
                {
                    ProcessResultsAction();
                }
                finally
                {
                    // Don't ever want to allow this to get an exception so we can get endinvoke exception
                    // want to make sure we stop from waiting, even on error
                    try
                    {
                        view.SetWait(true);
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("Error setting view wait: " + ex.ToString());
                    }
                }
            });
            return this;
        }
 
        /// <summary>
        /// 
        /// </summary>
        /// <param name="FinallyDelegate"></param>
        /// <returns>The thread executer object</returns>
        public ThreadedExecuter Finally(Action FinallyDelegate)
        {
            this.finallyDelegate = FinallyDelegate;
 
            return this;
        }
 
        /// <summary>
        /// Executes the <see cref="ThreadedExecuter"/>
        /// </summary>
        /// <returns>The thread executer object</returns>
        public ThreadedExecuter Run()
        {
            // Callpost action if any
            if (finallyDelegate != null)
            {
                worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(delegate(object sender, RunWorkerCompletedEventArgs e)
                {
                    try
                    {
                        finallyDelegate();
                    }
                    catch (Exception ex)
                    {
                        view.HandleException(ex);
                    }
                });
            }
 
            worker.RunWorkerAsync();
 
            return this;
        }
        #endregion
    }
}

			//////////////////////////////////////////////
			///Example String Compress DataTable
			//////////////////////////////////////////////
			//Client/Server Side
    			DataTable table = test.Copy().Tables[0];
			HelperClass.Compression.Compress(ref table);
 
			//Client/Server Side
			HelperClass.Compression.Decompress(ref table);
 
			//////////////////////////////////////////////
			///Other Example String Compress Datatable
			//////////////////////////////////////////////

 
			//Client/Server Side
			DataSet dstable = test.Copy();
			HelperClass.Compression.Compress(ref dstable);
 
			//Client/Server Side
			HelperClass.Compression.Decompress(ref dstable);
			
			//////////////////////////////////////////////
			///Other Example String DataSet
			//////////////////////////////////////////////

			//Client/Server Side
			String str = "Helo";
			HelperClass.Compression.Compress(ref str);
 
			//Client/Server Side
			HelperClass.Compression.Decompress(ref str);

/// <summary>
/// Runs this instance.
/// </summary>
/// <param name="timeOut">The time out.</param>
/// <returns></returns>
public ThreadedExecuter<T> Run(double timeOut)
{
    if (timeOut > 0)
    {
	worker.WorkerSupportsCancellation = true;
	timer = new System.Timers.Timer(timeOut);
	timer.Elapsed  += ((sender, e) =>
					  {
					      try
					      {
						  Terminate();
					      }
					      catch (Exception ex)
					      {
						  View.HandleException(ex);
					      }
					  });
	timer.Start();
    }
    return Run();
}
 
System.Timers.Timer timer = new System.Timers.Timer();
/// <summary>
/// Gets or sets the time in milliseconds to elapse before the executer should terminate itself.
/// </summary>
/// <value>The time out.</value>
public double TimeOut
{
    get { return timer.Interval; } 
}
 
/// <summary>
/// Terminates this instance.
/// </summary>
public void Terminate()
{
    if (timer.Enabled)
    {
	timer.Stop();
    }
    if (worker.IsBusy)
    {
	worker.CancelAsync();
    }
}