Generic InvocationHelper

/********************************************************************
 * InvocationHelper
 *	A generic class for providing thread-safe invocation of
 *	delegates.  Can be used for (but not limited to) updating GUI
 *	elements from another thread.
 * 
 * Edward Poore - mailto:ed.poore@gmail.com
 ********************************************************************
 * Disclaimer
 *	This code has been run so it does work.  However, it has not been
 *	thoroughly tested so use at your own risk.
 * 
 *	This code requires Generics, and therefore .NET 2.  I have no
 *	patience for any one who will try and run this on .NET 1.x.
 * 
 *  If you do try to do so then might I suggest you find another
 *	job/profession!
 * 
 * License
 *	Feel free to modify and use it where you want, commerical or
 *	otherwise.  However I would (like all others) like to be
 *	acknowledged somewhere.
 * 
 *	I'd also be curious to hear of any wierd and wacky places the
 *	code is used.  It'd be interesting to hear about even if it's
 *	not wierd and wacky :-).
 *******************************************************************/

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Text;

namespace SpitfireSystems
{
	public static class InvocationHelper<T>
	{
		public static void Invoke(T eventHandler)
		{
			InvocationHelper<T>.Invoke(eventHandler, null);
		}
		public static void Invoke(T eventHandler, params object[] arguments)
		{
			// Check that T is a delegate type
			if (!(eventHandler is Delegate))
			{
				throw new ArgumentException(string.Format("Type {0} is not derived from {1}", eventHandler.GetType().Name, typeof(Delegate).Name));
			}
			// Cast the to a delegate now since it's needed later
			Delegate handler = (eventHandler as Delegate);
			int requiredParameters = handler.Method.GetParameters().Length;
			// Check that the correct number of arguments have been supplied
			if (requiredParameters != arguments.Length)
			{
				throw new ArgumentException(string.Format("{0} arguments provided when {1} {2} required.", arguments.Length, requiredParameters, ((requiredParameters == 1) ? "is" : "are")));
			}
			// Get a local copy of the invocation list in case it changes
			Delegate[] invocationList = handler.GetInvocationList();
			// Check that it's not null
			if (invocationList == null)
			{
				return;
			}
			// Loop through delegates and check for ISynchronizeInvoke
			foreach (Delegate singleCastDelegate in invocationList)
			{
				ISynchronizeInvoke synchronizeTarget = singleCastDelegate.Target as ISynchronizeInvoke;
				// Check to see if the interface was supported
				if (synchronizeTarget == null)
				{
					// Invoke delegate normally
					singleCastDelegate.DynamicInvoke(arguments);
				}
				else
				{
					// Invoke through synchronization interface
					synchronizeTarget.BeginInvoke(singleCastDelegate, arguments);
				}
			}
		}
	}
}