Creating a thread in C# is close to trivial, but not quite. The only non-trivial thing about creating a thread is .NET delegate-classes. Let me explain in few words what is a delegate class. The delegate is a wrapper around a code construct in the .NET. The code construct could be an object instance, an instance method or a static method.

Delegates are used when you want to pass one of the three code constructs as a parameter to another method. When creating a new thread you have to use the ThreadStart delegate class to wrap the instance method that will be executed in the newly created thread. The instance method must return void and must not have any parameters.

void ThreadStart()

To create a new thread, first create a new ThreadStart object, passing the instance method of the thread procedure in the constructor. The new delegate object is then passed to the constructor of the Thread.

Thread thread = new Thread(
    new ThreadStart(obj.ThreadStart));

You've now created a new thread, but the thread is not yet started. To start the thread, you call the Thread.Start instance method.

thread.Start();

And that's it. You have a new running thread. A complete console application that creates a thread and outputs a couple messages to the console window is shown below.

using System;
using System.Threading;
namespace ConsoleApplication1
{
    class Class1
    {
        static void PrintHelloFromThreadName()
        {
            Console.WriteLine("Hello, from thread {0}",
                Thread.CurrentThread.Name); // {0}
        }

        public void ThreadStart()
        {
            PrintHelloFromThreadName();
        }

        static void Main(string[] args)
        {
            Thread.CurrentThread.Name = "Main thread";
            Class1 obj = new Class1();
            Thread thread = new Thread(
                new ThreadStart(obj.ThreadStart));
            thread.Name = "Forked thread";
            thread.Start();
            PrintHelloFromThreadName();
        }
    }
}

A nice feature of .NET threads, and for that matter any .NET object, is the ability name the object. If you name your threads, then the debugger will pick up those names and you'll have a much easier time debugging (see Figure 1). The frame in the bottom left of the IDE window in Figure 1 shows all the threads in out C# application. I set a breakpoint in the PrintHelloFromThread Name static method in Listing 1 and ran the application. When the application stops on the breakpoint, I called up the threads window from the menu bar, Debug | Window | Threads. As you can see, the Name in the threads window of the IDE is the same as the name given the Thread object in our C# code.