Great series of Separation of Concern by Jimmy Bogard

I just finished reading Jimmy Bogard's 5 series of Separation of Concern by example and they are just too awesome to be missed out.

The series :
# Separation of Concerns - how not to do it
# Separation of Concerns by example: Part 1 - Refactoring away from static class
# Separation of Concerns by example: Part 2 - Specialized interface for Cache
# Separation of Concerns by example: Part 3 - Creating the repository
# Separation of Concerns by example: Part 4 - Fixing a bug with unit test
# Separation of Concerns by example: Part 5 - Dependency Injection with StructureMap

The best thing that I like about them is that they are based on a real world example :D
Enuf said, go and see for your self ;)

Testing Concurrency using ThreadPool (Multithread)

There are times when we need to test our code in concurrent manner where there are some numbers of instances running simultaneously.

This is different with the invocation such as below code where the method will be executed in sequential manner, this kind of test may be useful to test how long it may take to execute the method.

for (int iTest = 0; iTest < 100; iTest++) {     TestingMethodA(); }

 

For this testing concurrency, I’m using Joseph Albahari’s Threading in C# articles in ThreadPooling section as references to the MultiThreadRunner class that I created.

Code below in plain English : Submit 5 invocations of TestingMethodA with 10 maximum concurrent threads.

MultiThreadRunner runner = new MultiThreadRunner();            runner.Run(new MultiThreadRunner.ParameterlessMethodDelegate(TestingMethodA), 5, 10);

 

The MultiThreadRunner class :

class MultiThreadRunner {     static object workerLocker = new object();     static int runningWorkers = 0;     /// <summary>     /// The delegate is to be used as a placeholder for a parameterless method to invoke     /// </summary>     public delegate void ParameterlessMethodDelegate();     /// <summary>     /// An overload to Run method, set the concurrentNoOfInstances to a default no     /// </summary>     /// <param name="myMethod">The method to be invoke, passed as a delegate</param>     /// <param name="noOfInvocations">Total no of invocations to execute</param>     public void Run(Delegate myMethod, int noOfInvocations)     {         this.Run(myMethod, noOfInvocations, 0);     }     /// <summary>     /// The method will submit the method into the ThreadPool     /// </summary>     /// <param name="myMethod">The method to be invoke, passed as a delegate</param>     /// <param name="noOfInvocations">Total no of invocations to execute</param>     /// <param name="concurrentNoOfInstances">Concurrent no of instances -> ThreadPool.MinThreads</param>     public void Run(Delegate myMethod, int noOfInvocations, int concurrentNoOfInstances)     {         int iRow = runningWorkers = noOfInvocations;         int iStartWorker, iEndWorker, iCompletion;         // Adjust the min threads         SetMinThreads(concurrentNoOfInstances);         ThreadPool.GetAvailableThreads(out iStartWorker, out iCompletion);         Debug.WriteLine(string.Format("Available Threads, Start : {0}", iStartWorker));         for (int i = 1; i <= iRow; i++)         {             ThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(InvokeMethod), myMethod);             Debug.WriteLine("Submitted a queue : " + i.ToString());         }         lock (workerLocker)         {             while (runningWorkers > 0) Monitor.Wait(workerLocker);         }         ThreadPool.GetAvailableThreads(out iEndWorker, out iCompletion);         Debug.WriteLine(string.Format("All threads have been completed, Start : {0} - End : {1} - Completion : {2}", iStartWorker, iEndWorker, iCompletion));     }     /// <summary>     /// Set the ThreadPool Mininum Threads, this is to avoid a delay bottleneck, please refer to http://msdn.microsoft.com/en-us/library/system.threading.threadpool.aspx     /// </summary>     /// <param name="concurrentNoOfInstances"></param>     private void SetMinThreads(int concurrentNoOfInstances)     {         int iMaxWorker, iMinWorker, iCompletion;         ThreadPool.GetMaxThreads(out iMaxWorker, out iCompletion);         ThreadPool.GetMinThreads(out iMinWorker, out iCompletion);         if (concurrentNoOfInstances != 0)         {             if (concurrentNoOfInstances > iMaxWorker)             {                 ThreadPool.SetMinThreads(iMaxWorker, iCompletion);                 Debug.WriteLine("The requested concurrent no of instances is higher than max threads, set the min threads as max threads : " + iMaxWorker);             }             else             {                 ThreadPool.SetMinThreads(concurrentNoOfInstances, iCompletion);                 Debug.WriteLine("Set the min threads to " + concurrentNoOfInstances);             }         }         else         {             Debug.WriteLine("Using the default min threads : " + iMinWorker);         }     }     /// <summary>     /// To invoke the method     /// </summary>     /// <param name="myMethod"></param>     private void InvokeMethod(object myMethod)     {         Debug.WriteLine("Invoke the method in thread : " + Thread.CurrentThread.ManagedThreadId);         ((Delegate)myMethod).DynamicInvoke(null);         lock (workerLocker)         {             runningWorkers--; Monitor.Pulse(workerLocker);         }     } }

or get the complete project from here :

 

Hope this helps with your test as well :D

Running xUnit Console inside VS Express IDE

I just downloaded the VS 2008 Express SP1 yesterday, and got excited because now the Visual Web Developer 2008 Express Edition supports Web Application and Class Library Projects, so more things can be done with the express edition, thanks to the VS Express team ;)

Usually we can use the unit test inside the VS IDE itself by using TestDriven.Net, however express edition will not support VS addins, so yeah it's the downside of it but anyway it's FREE, so live with it :P

I'm currently using xUnit which comes with a GUI interface and a console runner, i find it always better if we can use it inside the VS IDE itself without having to switch program using ALT+TAB to run the GUI / Console runner.

Wouldn't it be nicer if we can do it inside the IDE itself? So this is how i setup it in my VS IDE :
1. Go to Tools -> External Tools
2. Add new menu :

• Title : x&Unit (& is used for shorcut keys)
  
• Command : D:\Extension\xUnit\xunit.console.exe (This should be the your console runner location)
  
• Arguments : $(BinDir)$(TargetName)$(TargetExt)
  **Updates : In VS2005 / VS2003 : $(ItemDir)bin\Debug\$(TargetName)$(TargetExt)
  
• Check the Use Output window
  

Now in the Tools menu, you can find the new xUnit menu item.

So now, after you finish building the project, you only need to use the shortcut ALT T+U and it will out like this below :)


**Updates :
This is how to bind a keyboard shortcut to the unit test menu item, based on Distant Sounds's comment.
You will need to choose Tools.ExternalCommand(n), where n is the sequence order of your unit test menu item.
and then you get another option to execute the unit test ;)

Hope this helps ;)