can you post the source code for this example?

Thank you

using System;
using System.Linq;
using System.Linq.Expressions;
using System.ComponentModel;
using System.Threading;
using System.Collections.Generic;
using System.Text;

namespace DB
{
public class DoWorkArg
{
public T Arg { get; private set; }
public Action ReportProgress;
public Action CancelAsync;

public DoWorkArg(T Arg, Action reportProgress, Action cancelAsync)
{
this.Arg = Arg;
this.ReportProgress = reportProgress;
this.CancelAsync = cancelAsync;
}
}

public class WorkerResult
{
public T Result { get; private set; }
public Exception Error { get; private set; }
public bool Cancelled { get; private set; }

public WorkerResult(T result, Exception error, bool cancelled)
{
this.Result = result;
this.Error = error;
this.Cancelled = cancelled;
}
}

public class WorkerProgress
{
public int ProgressPercentage { get; private set; }
public Tus UserState { get; private set; }

public WorkerProgress(int progressPercentage, Tus userState)
{
this.ProgressPercentage = progressPercentage;
this.UserState = userState;
}
}

public class QueueItem
{
public Tin Arg { get; private set; }
public BackgroundWorker BackgroundWorker { get; private set; }

public QueueItem(BackgroundWorker backgroundWorker, Tin Arg)
{
this.BackgroundWorker = backgroundWorker;
this.Arg = Arg;
}
}

//public static class QueuedBackgroundWorker
//{
// public static void QueueWorkItem(
// Queue<QueueItem> queue,
// Tin inputArg,
// Func<DoWorkArg, Tout> doWork,
// Action<WorkerResult> workerCompleted)
// {
// if (queue == null)
// {
// throw new ArgumentNullException(”queue”);
// }
// BackgroundWorker bw = new BackgroundWorker();

// bw.WorkerReportsProgress = true;
// bw.WorkerSupportsCancellation = true;
// bw.DoWork += (sender, args) =>
// {
// if (doWork != null)
// {
// args.Result = doWork(new DoWorkArg((Tin)args.Argument));
// }
// };

// bw.RunWorkerCompleted += (sender, args) =>
// {
// if (workerCompleted != null)
// {
// workerCompleted(new WorkerResult((Tout)args.Result, args.Error));
// }
// queue.Dequeue();
// if (queue.Count > 0)
// {
// QueueItem nextItem = queue.Peek();
// nextItem.BackgroundWorker.RunWorkerAsync(nextItem.Arg);
// }
// };

// queue.Enqueue(new QueueItem(bw, inputArg));
// if (queue.Count == 1)
// {
// QueueItem nextItem = queue.Peek();
// nextItem.BackgroundWorker.RunWorkerAsync(nextItem.Arg);
// }
// }
//}

public static class BackgroundWorkerHelper
{
public static void DoWork(
Tin inArg,
Func<DoWorkArg, Tout> doWork,
Action<WorkerResult> workerCompleted,
Action<WorkerProgress> progressChanged)
{
BackgroundWorker bw = new BackgroundWorker();

bw.WorkerReportsProgress = true;
bw.WorkerSupportsCancellation = true;
bw.DoWork += (sender, args) =>
{
if (doWork != null)
{
Action reportProgress = new Action(bw.ReportProgress);
Action cancelAsync = new Action(bw.CancelAsync);
args.Result = doWork(new DoWorkArg((Tin)args.Argument, reportProgress, cancelAsync));
}
};
bw.RunWorkerCompleted += (sender, args) =>
{
if (workerCompleted != null)
{
workerCompleted(new WorkerResult((Tout)args.Result, args.Error, args.Cancelled));
}
};
bw.ProgressChanged += (sender, args) =>
{
if (progressChanged != null)
{
progressChanged(new WorkerProgress(args.ProgressPercentage, (Tus)args.UserState));
}
};
bw.RunWorkerAsync(inArg);
}
}
}

///
/// Creates a BackgroundWorker and hooks up to its DoWork and RunWorkerCompleted events.
/// This does not support cancellation or reporting of progress.
///
///
///
/// input argument of type Tin
/// generic delegate which takes one
/// input parameter, a DoWorkArgument object, and returns an object of type Tout.
/// generic delegate which must have a method
/// specified that accepts one input object of type WorkerResult and does not return anything.
public static void DoWork(
Tin inputArgument,
Func<DoWorkArgument, Tout> doWork,
Action<WorkerResult> workerCompleted) {
BackgroundWorker bw = new BackgroundWorker();
bw.WorkerReportsProgress = false;
bw.WorkerSupportsCancellation = false;
bw.DoWork += (sender, args) => {
if (doWork != null) {
args.Result = doWork(new DoWorkArgument((Tin)args.Argument));
}
};
bw.RunWorkerCompleted += (sender, args) => {
if (workerCompleted != null) {
workerCompleted(new WorkerResult((Tout)args.Result, args.Error));
}
};
bw.RunWorkerAsync(inputArgument);
}

///
/// Similar to the above, except, use if one has a long-running method that
/// doesn’t take any input parameters, but needs to update the UI when it is done.
///
///
/// generic delegate which takes no
/// input parameter, but returns an object of type Tout.
/// generic delegate which must have a method
/// specified that accepts one input object of type WorkerResult and does not return anything.
public static void DoWork(
Func doWork,
Action<WorkerResult> workerCompleted) {
BackgroundWorker bw = new BackgroundWorker();
bw.WorkerReportsProgress = false;
bw.WorkerSupportsCancellation = false;
bw.DoWork += (sender, args) => {
if (doWork != null) {
args.Result = doWork();
}
};
bw.RunWorkerCompleted += (sender, args) => {
if (workerCompleted != null) {
workerCompleted(new WorkerResult((Tout)args.Result, args.Error));
}
};
bw.RunWorkerAsync();
}

public delegate void Func();

///
/// Similar to the above, except, use if one has a long-running method that
/// doesn’t take any input parameters, does not return output, but may need
/// to update the UI when it is done.
///
/// generic delegate which takes no
/// input parameter, and returns no output.
///
public static void DoWork(
Func doWork,
Action workerCompleted) {
BackgroundWorker bw = new BackgroundWorker();
bw.WorkerReportsProgress = false;
bw.WorkerSupportsCancellation = false;
bw.DoWork += (sender, args) => {
if (doWork != null) {
doWork();
}
};
bw.RunWorkerCompleted += (sender, args) => {
if (workerCompleted != null) {
workerCompleted(args.Error);
}
};
bw.RunWorkerAsync();
}
}

///
/// input argument of type Tin that gets passed to the DoWork event handler
/// on a different thread.
///
///
public class DoWorkArgument {
public T Argument { get; private set; }

public DoWorkArgument(T argument) {
this.Argument = argument;
}
}

///
/// return value of type Tout
///
///
public class WorkerResult {
public T Result { get; private set; }
public Exception Error { get; private set; }

public WorkerResult(T result, Exception error) {
this.Result = result;
this.Error = error;
}
}
}