using ThreadStatic variables with async/await

You could use CallContext.LogicalSetData and CallContext.LogicalGetData, but I recommend you don't because they don't support any kind of "cloning" when you use simple parallelism (Task.WhenAny / Task.WhenAll).

I opened a UserVoice request for a more complete async-compatible "context", explained in more detail in an MSDN forum post. It does not seem possible to build one ourselves. Jon Skeet has a good blog entry on the subject.

So, I recommend you use argument, lambda closures, or the members of the local instance (this), as Marc described.

And yes, OperationContext.Current is not preserved across awaits.

Update: .NET 4.5 does support Logical[Get|Set]Data in async code. Details on my blog.

Basically, I would emphasize: don't do that. [ThreadStatic] is never going to play nicely with code that jumps between threads.

But you don't have to. A Task already carries state - in fact, it can do it 2 different ways:

• there's an explicit state object, which can hold everything you need
• lambdas/anon-methods can form closures over state

Additionally, the compiler does everything you need here anyway:

private static async Task Start(){    string secret = "moo moo";    Console.WriteLine("Started on thread [{0}]",        Thread.CurrentThread.ManagedThreadId);    Console.WriteLine("Secret is [{0}]", secret);    await Sleepy();    Console.WriteLine("Finished on thread [{0}]",        Thread.CurrentThread.ManagedThreadId);    Console.WriteLine("Secret is [{0}]", secret);}

No static state; no issues with threads or multiple tasks. It just works. Note that secret is not just a "local" here; the compiler has worked some voodoo, like it does with iterator blocks and captured variables. Checking reflector, I get:

[CompilerGenerated]private struct <Start>d__0 : IAsyncStateMachine{    // ... lots more here not shown    public string <secret>5__1;}

Getting a task continuation to execute on the same thread requires a synchronization provider. That's an expensive word, the simple diagnostic is by looking at the value of System.Threading.SynchronizationContext.Current in the debugger.

That value will be null in console mode app. There is no provider that can make code run on a specific thread in a console mode app. Only a Winforms or WPF app or ASP.NET app will have a provider. And only on their main thread.

The main thread of these apps do something very special, they have a dispatcher loop (aka message loop or message pump). Which implements the general solution to the producer-consumer problem. It is that dispatcher loop that allows handing a thread a bit of work to perform. Such a bit of work will be the task continuation after the await expression. And that bit will run on the dispatcher thread.

The WindowsFormsSynchronizationContext is the synchronization provider for a Winforms app. It uses Control.Begin/Invoke() to dispatch the request. For WPF it is the DispatcherSynchronizationContext class, it uses Dispatcher.Begin/Invoke() to dispatch the request. For ASP.NET it is the AspNetSynchronizationContext class, it uses invisible internal plumbing. They create an instance of their respective providers in their initialization and assign it to SynchronizationContext.Current

There's no such provider for a console mode app. Primarily because the main thread is entirely unsuitable, it doesn't use a dispatcher loop. You would have create your own, then also create your own SynchronizationContext derived class. Hard to do, you can't make a call like Console.ReadLine() anymore since that entirely freezes the main thread on a Windows call. Your console mode app stops being a console app, it will start resembling a Winforms app.

Do note that these runtime environments have synchronization providers for a good reason. They have to have one because a GUI is fundamentally thread-unsafe. Not a problem with the Console, it is thread-safe.