can you post the source code for this example?

Thank you

I did notice your discussion about the Service Locator (anti)pattern in your upcoming book (MEAP Ch 5).

This brings up some very interesting points. I need to dig in and learn more.

Much more about that in my book

With that in mind I consider the Common Service Locator redundant at best. Personally, I would never take a depedency on it.

I’m assuming it’s a reference to an anonymous object, but I’m not sure.

What’s nice about the CSL is that it is created in collaboration with people from the major IoC frameworks.

There are however still some things that has to be sorted out. Look for instance at this discussion I started: http://commonservicelocator.codeplex.com/Thread/View.aspx?ThreadId=77730. Next to that there are some minor issues, like this one: http://commonservicelocator.codeplex.com/WorkItem/View.aspx?WorkItemId=9676.

Have you ever seen the Common Service Locator project? http://commonservicelocator.codeplex.com/. In itself it’s not a DI framework, but it’s a shared interface for plugging in DI frameworks.

Cheers

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);
}
}
}