How to tell if a thread is the main thread in C#

You could do it like this:

// Do this when you start your application
static int mainThreadId;

// In Main method:
mainThreadId = System.Threading.Thread.CurrentThread.ManagedThreadId;

// If called in the non main thread, will return false;
public static bool IsMainThread
{
    get { return System.Threading.Thread.CurrentThread.ManagedThreadId == mainThreadId; }
}

EDIT I realized you could do it with reflection too, here is a snippet for that:

public static void CheckForMainThread()
{
    if (Thread.CurrentThread.GetApartmentState() == ApartmentState.STA &&
        !Thread.CurrentThread.IsBackground && !Thread.CurrentThread.IsThreadPoolThread && Thread.CurrentThread.IsAlive)
    {
        MethodInfo correctEntryMethod = Assembly.GetEntryAssembly().EntryPoint;
        StackTrace trace = new StackTrace();
        StackFrame[] frames = trace.GetFrames();
        for (int i = frames.Length - 1; i >= 0; i--)
        {
            MethodBase method = frames[i].GetMethod();
            if (correctEntryMethod == method)
            {
                return;
            }
        }
    }

    // throw exception, the current thread is not the main thread...
}

If you're using Windows Forms or WPF, you can check to see if SynchronizationContext.Current is not null.

The main thread will get a valid SynchronizationContext set to the current context upon startup in Windows Forms and WPF.

It is much more easy:

static class Program
{
  [ThreadStatic]
  public static readonly bool IsMainThread = true;

//...
}

And you can use it from any thread:

if(Program.IsMainThread) ...

Explanation:

The IsMainThread field's initializer gets compiled into a static constructor which gets run when the class is first used (technically, before the first access of any static member). Assuming the class is first used on the main thread, the static constructor will be called and the field will be set to true on the main thread.

Since the field has the [ThreadStatic] attribute, it has an independent value in each thread. The initializer runs only once, in the first thread that accesses the type, so the value in that thread is true, but the field remains uninitialized in all other threads, with a value of false.

In a WPF app, here is another option:

if (App.Current.Dispatcher.Thread == System.Threading.Thread.CurrentThread)
{
    //we're on the main thread
}

In a Windows Forms app, this will work as long as there's at least one Form open:

if (Application.OpenForms[0].InvokeRequired)
{
    //we're on the main thread
}