Which would allow me to then call the method I want to start on a new thread type-safely.

So, lets start back at the beginning, how do we use the current ParameterizedThreadStart? I have the following method that I want to run in a new thread:

private void Inty(int anInt)
{
    int sleepTime = 1000 / anInt;

    for (int i = 0; i < anInt; i++)
    {
        Console.WriteLine("An Int! " + anInt);
        Thread.Sleep(sleepTime);
    }
}

It's a very simple method, that writes out a message from a for loop, and sleeps for a set time. For me to use this with the current ParameterizedThreadStart I would do this:

Thread t = new Thread(new ParameterizedThreadStart(Inty));
t.Start(5);

Which also requires a change to the 'Inty' method:

     private void Inty(object obj)
     {
         int anInt = Convert.ToInt32(obj);
         ...
     }

Which means I lose all my typesafety, as I can now call my thread such:

t.Start("HULLO!");
t.Start(new object());
t.Start(null);

All valid compile-wise, not good at run-time, as a consequence, I should add some validity checks into 'Inty'. But I just would rather not have to do this.

This brought me to write a wrapper for the Thread class, I called it 'Thread' (but in a different namespace), so the code would look the same;

First I needed a generic ParameterizedThreadStart delegate:

public delegate void ParameterizedThreadStart<T>(T argument);

Now I've got that, it's time to create a wrapper, we can't extend System.Threading.Thread as it's a sealed class, so wrapping is our lot. The idea is that I want to be able to create my new thread, and then call 'Start' on it just as a normal thread.

My solution is below;

using System.Threading;

public class Thread<T>
{
    public string Name { get { return mTheThread.Name; } set { mTheThread.Name = value; } }
    
    private Thread mTheThread;
    private ParameterizedThreadStart<T> mTheDelegate;

    public Thread(ParameterizedThreadStart<T> theDelegate)
    {
        mTheDelegate = theDelegate;
        mTheThread = new Thread(new ParameterizedThreadStart(Run));
    }

    public void Start(T theArgument)
    {
        mTheThread.Start(theArgument);
    }

    private void Run(object arg)
    {
        T theArgument = (T) arg;
        mTheDelegate(theArgument);
    }
}

I wrap a System.Threading.Thread which I construct and initialise in the constructor. The ParameterizedThreadStart<> which I pass in to the constructor I store as a member variable, ready to be run in the private 'Run' method. The Run method is a match to a standard ParameterizedThreadStart delegate, and performs a cast to the correct type. This cast is safe, as the whole class is made 'generic'.

So, to use the new Thread class:

Thread<int> t = new Thread<int>(new ParameterizedThreadStart<int>(Inty));
t.Start(5);

I don't have to make any changes to 'Inty' which is nice, and the compiler will complain if I try to call 'start' with any value other than an int. Equally, if I try to set up the ParameterizedThreadStart<> with anything other than an int the compiler will complain.

The only thing I don't really like is the way I have to put 'int' 3 times in that constructing row, I would prefer something like:

Thread t = new Thread(new ParameterizedThreadStart<int>(Inty));

but, for type safety I can live with it.