Here is a cool little way I came up with to start a normal thread or a
threadpool thread (fire and forget) with strong typing using a generic
delegate.
It required a little helper class which you could name anything and put in
your Utils lib. IMO, it is nice in the sense that it normalizes all the
different delegates (i.e. ThreadStart, WaitCallback,
ParameterizedThreadStart) into one generic delegate
(ParameterizedThreadStart<T>) that can be used to start either a new thread
or run on the thread pool. Makes you wonder why they did not add a
ParameterizedThreadStart<T> delegate in this version? Also wonder why they
added a new delegate (i.e. ParameterizedThreadStart) when WaitCallback would
do. Anyway, here you go.
// Test
RunThread.Test();
-- Output:
Passed string:[Method run on new thread.] IsThreadPool:False
Passed string:[Method run on a thread pool thread.] IsThreadPool:True
Passed string:[Anonymous method run on a thread pool thread.]
IsThreadPool:True
Below is the class. Very small amount of code needed, most is comments:
---------------------------------------------
using System;
using System.Threading;
/// <summary>
/// Generic parameterized delegate.
/// </summary>
public delegate void ParameterizedThreadStart<T>(T value);
public static class RunThread
{
/// <summary>
/// Creates and starts a new Thread which runs the parameterized
delegate.
/// </summary>
/// <typeparam name="T">The type.</typeparam>
/// <param name="start">The generic delegate.</param>
/// <param name="value">The type to pass to delegate.</param>
/// <returns>The Thread instance.</returns>
public static Thread Start<T>(ParameterizedThreadStart<T> start, T value)
{
if (start == null)
throw new ArgumentNullException("start");
// Just call the ParameterizedThreadStart<T> delegate within a new
thread.
Thread t = new Thread(delegate()
{
start(value);
});
t.Start();
return t;
}
/// <summary>
/// Queues a delegate to run on a thread pool thread.
/// </summary>
/// <typeparam name="T">The type.</typeparam>
/// <param name="start">The generic delegate.</param>
/// <param name="value">The type to pass to delegate.</param>
public static void StartOnThreadPool<T>(ParameterizedThreadStart<T>
start, T value)
{
if (start == null)
throw new ArgumentNullException("start");
// We use this method instead of BeginInvoke so we get fire and
forget semantics.
ThreadPool.QueueUserWorkItem(delegate(object obj)
{
start(value);
});
//Note: don't use BeginInvoke unless you also take care to handle
the EndInvoke.
}
#if DEBUG
/// <summary>
/// Run "RunThread.Test()" to test in debug.
/// </summary>
public static void Test()
{
RunThread.Start(new ParameterizedThreadStart<string>(RunThis),
"Method run on new thread.");
// Start new thread pool thread with type safe parameter.
RunThread.StartOnThreadPool(new
ParameterizedThreadStart<string>(RunThis), "Method run on a thread pool
thread.");
// Start anonomous method on the thread pool.
RunThread.StartOnThreadPool(delegate(string s)
{
Console.WriteLine("Passed string:[{0}] IsThreadPool:{1}", s,
Thread.CurrentThread.IsThreadPoolThread);
}, "Anonymous method run on a thread pool thread.");
}
// Some method that takes a parm that we want to run.
private static void RunThis(string value)
{
Console.WriteLine("Passed string:[{0}] IsThreadPool:{1}", value,
Thread.CurrentThread.IsThreadPoolThread);
}
#endif
}
--
William Stacey [MVP]
"Andrew Bullock" <an*********************@ANDntlworldTHIS.com> wrote in
message news:Ga******************@newsfe3-gui.ntli.net...
| Hi,
|
| code:
|
| myClass x = new myClass();
| x.dosomethingwith(x,y);
|
|
| How do i make dosomethingwith(x,y) run on a separate thread, and then
| inform the main thread when it has finished?
|
| I can do all of the above without the arguments (x,y) using a callback
| delegate, but not with arguments?
|
| Hope someone can help :)
|
| Regards
|
| Andrew
