Is using ThreadStatic in .NET Framework code a harmful relic of a bygone age?

Question

[ThreadStatic] used in various places on the .NET platform to provide the context for various functions (for example, Transaction.Current , which is used for TransactionScope ).

Unfortunately, this means that functions that perform some thread manipulation (ASP.NET, async key code) switch threads but do not copy TransactionScope , so functions like TransactionScope do not work as you might expect .

There is another mechanism, CallContext.LogicalGetData (more here ) that correctly copies state during stream switches (at least in .NET 4.5). It seems to me that TransactionScope would be better if it used this and not [ThreadStatic] .

If functions that use [ThreadStatic] were written today, instead of being existing functions with backward compatibility requirements, could they be written using CallContext.(G|S)etLogicalData ?

Answer 1

In fact, they have very different uses.

• ThreadStatic cannot pass a value through await or a similar context switch.
• CallContext cannot save the value for the stream.

So you cannot replace another. ThreadStatic is a low-level primitive. I do not think its use cases have become smaller after CallContext , etc. Have come. Notice that its use cases are vanishingly small - I think the last time I used it was probably over two years ago.

I would describe things like Transaction.Current as an abuse of TLS. It was never intended for this, and therefore, when TLS seemed to break asynchrony, it was only because it was never used for this in the first place.

Answer 2

Yes. I'm sure it seemed like a good idea at the time, but [ThreadStatic] lulls developers into a false sense of security. ThreadStatic fields have many disadvantages of global variables, and the only advantage (different threads have their own instances of a global thing) has a corresponding disadvantage (this thing disappears if you switch threads). This is not a win. The globals suck, and the flow-static globals suck in every bit in the same way as a regular one.

I’m working on a rather large code base, several years with dozens of developers (maybe a couple of hundred if you could leave the team in the last few years), and [ThreadStatic] will regularly bite us. We have tons of code that uses global ThreadStatic, which, of course, breaks if you do something in the workflow. As I said, I’m sure that at the time it seemed like a good idea ... but now it cost us much more than it ever bought us.

An alternative could be passing the same object (HttpContext, Transaction, etc.) for each method that depends on it. This requires more typing, but in my not very modest opinion, in the end it is still better.