To some readers, the title of this post may induce nightmarish recollections of late-night debugging sessions. To others it may be simply the epitome of jargon. Just to break the jargon down a bit:
- Type initializer: the code executed to initialize the static variables of a class, and the static constructor
- Circular dependency: two bits of code which depend on each other – in this case, two classes whose type initializers each require that the other class is initialized
A quick example of the kind of problem I’m talking about would be helpful here. What would you expect this code to print?
using System;
class Test
{
static void Main()
{
Console.WriteLine(First.Beta);
}
}
class First
{
public static readonly int Alpha = 5;
public static readonly int Beta = Second.Gamma;
}
class Second
{
public static readonly int Gamma = First.Alpha;
}
Of course, without even glancing at the specification, any expectations are pretty irrelevant. Here’s what the spec (section 10.5.5.1 of the C# 4 version):
The static field variable initializers of a class correspond to a sequence of assignments that are executed in the textual order in which they appear in the class declaration. If a static constructor (§10.12) exists in the class, execution of the static field initializers occurs immediately prior to executing that static constructor. Otherwise, the static field initializers are executed at an implementation-dependent time prior to the first use of a static field of that class.
In addition to the language specification, the CLI specification gives more details about type initialization in the face of circular dependencies and multiple threads. I won’t post the details here, but the gist of it is:
- Type initialization acts like a lock, to prevent more than one thread from initializing a type
- If the CLI notices that type A needs to be initialized in order to make progress, but it’s already in the process of initializing type A in the same thread, it continues as if the type were already initialized.
So here’s what you might expect to happen:
- Initialize Test: no further action required
- Start running Main
- Start initializing First (as we need First.Beta)
- Set First.Alpha to 5
- Start initializing Second (as we need Second.Gamma)
- Set Second.Gamma to First.Alpha (5)
- End initializing Second
- Set First.Beta to Second.Gamma (5)
- End initializing First
- Print 5
Here’s what actually happens – on my box, running .NET 4.5 beta. (I know that type initialization changed for .NET 4, for example. I don’t know of any changes for .NET 4.5, but I’m not going to claim it’s impossible.)
- Initialize Test: no further action required
- Start running Main
- Start initializing First (as we need First.Beta)
- Start initializing Second (we will need Second.Gamma)
- Set Second.Gamma to First.Alpha (0)
- End initializing Second
- Set First.Alpha to 5
- Set First.Beta to Second.Gamma (0)
- End initializing First
- Print 0
Step 5 is the interesting one here. We know that we need First to be initialized, in order to get First.Alpha, but this thread is already initializing First (we started in step 3) so we just access First.Alpha and hope that it’s got the right value. As it happens, that variable initializer hasn’t been executed yet. Oops.
(One subtlety here is that I could have declared all these variables as constants instead using "const" which would have avoided all these problems.)
Back in the real world…
Hopefully that example makes it clear why circular dependencies in type initializers are nasty. They’re hard to spot, hard to debug, and hard to test. Pretty much your classic Heisenbug, really. It’s important to note that if the program above had happened to initialize Second first (to access a different variable, for example) we could have ended up with a different result. In particular, it’s easy to get into a situation where running all your unit tests can cause a failure – but if you run just the failing test, it passes.
One way of avoiding all of this is never to use any type initializers for anything, of course. In many cases that’s exactly the right solution – but often there are natural uses, particularly for well-known values such as Encoding.Utf8, TimeZoneInfo.Utc and the like. Note that in both of those cases they are static properties, but I would expect them to be backed by static fields. I’m somewhat ambivalent between using public static readonly fields and public static get-only properties – but as we’ll see later, there’s a definite advantage to using properties.
Noda Time has quite a few values like this – partly because so many of its types are immutable. It makes sense to create a single UTC time zone, a single ISO calendar system, a single "pattern" (text formatter/parser) for each of a variety of common cases. In addition to the publicly visible values, there are various static variables used internally, mostly for caching purposes. All of this definitely adds complexity – and makes it harder to test – but the performance benefits can be significant.
Unfortunately, a lot of these values end up with fairly natural circular dependencies – as I discovered just recently, where adding a new static field caused all kinds of breakage. I was able to fix the immediate cause, but it left me concerned about the integrity of the code. I’d fixed the one failure I knew about – but what about any others?
Testing type initialization
One of the biggest issues with type initialization is the order-sensitivity – combined with the way that once a type has been initialized once, that’s it for that AppDomain. As I showed earlier, it’s possible that initializing types in one particular order causes a problem, but a different order won’t.
I’ve decided that for Noda Time at least, I want to be reasonably sure that type initialization circularity isn’t going to bite me. So I want to validate that no type initializers form cycles, whatever order the types are initialized in. Logically if we can detect a cycle starting with one type, we ought to be able to detect it starting with any of the other types in that cycle – but I’m sufficiently concerned about weird corner cases that I’d rather just take a brute force approach.
So, as a rough plan:
- Start with an empty set of dependencies
- For each type in the target assembly:
- Create a new AppDomain
- Load the target assembly into it
- Force the type to be initialized
- Take a stack trace at the start of each type initializer and record any dependencies
- Look for cycles in the complete set of dependencies
Note that we’ll never spot a cycle within any single AppDomain, due to the way that type initialization works. We have to put together the results for multiple initialization sequences to try to find a cycle.
A description of the code would probably be harder to follow than the code itself, but the code is relatively long – I’ve included it at the end of this post to avoid intefering with the narrative flow. For more up-to-date versions in the future, look at the Noda Time repository.
This isn’t a terribly nice solution, for various reasons:
So with all these caveats, is it still worth it? Absolutely: it’s already found bugs which have now been fixed.
In fact, the test didn’t get as far as reporting cycles to start with – it turned out that if you initialized one particular type first, the type initializer would fail with a NullReferenceException. Ouch! Once I’d fixed that, there were still quite a few problems to fix. Somewhat coincidentally, fixing them improved the design too – although the user-visible API didn’t change at all.
Fixing type initializer cycles
In the past, I’ve occasionally "fixed" type initialization ordering problems by simply moving fields around. The cycles still existed, but I figured out how to make them harmless. I can say now that this approach does not scale, and is more effort than it’s worth. The code ends up being brittle, hard to think about, and once you’ve got more than a couple of types involved it’s really error-prone, at least for my brain. It’s much better to break the cycle completely. To this end, I’ve ended up using a fairly simple technique to defer initialization of static variables. It’s a poor-man’s Lazy<T>, to some extent – but I’d rather not have to write Lazy<T> myself, and we’re currently targeting .NET 3.5…
Basically, instead of exposing a public static readonly field which creates the cycle, you expose a public static readonly property – which returns an internal static readonly field in a nested, private static class. We still get the nice thread-safe once-only initialization of a type initializer, but the nested type won’t be initialized until it needs to be. (In theory it could be initialized earlier, but a static constructor would ensure it isn’t.) So long as nothing within the rest of the type initializer for the containing class uses that property, we avoid the cycle.
So instead of this:
public static readonly Foo SimpleFoo = new Foo(Bar.Zero);
We might have:
public static readonly Foo SimpleFoo { get {
return Constants.SimpleFoo; } }
private static class Constants
{
private static readonly int TypeInitializationChecking = NodaTime.Utility.TypeInitializationChecker.RecordInitializationStart();
internal static readonly Foo SimpleFoo = new Foo(Bar.Zero);
}
I’m currently undecided about whether to include static constructors in these classes to ensure lazy initialization. If the type initializer for Foo triggered the initializer of Foo.Constants, we’d be back to square one… but adding static constructors into each of these nested classes sounds like a bit of a pain. The nested classes should call into the type initialization checking as well, to validate they don’t cause any problems themselves.
Conclusion
I have to say, part of me really doesn’t like either the testing code or the workaround. Both smack of being clever, which is never a good thing. It’s definitely worth considering whether you could actually just get rid of the type initializer (or part of it) entirely, avoiding maintaining so much static state. It would be nice to be able to detect these type initializer cycles without running anything, simply using static analysis – I’m going to see whether NDepend could do that when I get a chance. The workaround doesn’t feel as neat as Lazy<T>, which is really what’s called for here – but I don’t trust myself to implement it correctly and efficiently myself.
So while both are somewhat hacky, they’re better than the alternative: buggy code. That’s what I’m ashamed to say I had in Noda Time, and I don’t think I’d ever have spotted all the cycles by inspection. It’s worth a try on your own code – see whether you’ve got problems lurking…
Appendix: Testing code
As promised earlier, here’s the code for the production and test classes.
TypeInitializationChecker
This is in NodaTime.dll itself.
internal sealed class TypeInitializationChecker : MarshalByRefObject
{
private static List<Dependency> dependencies =
null;
private static readonly MethodInfo EntryMethod = typeof(TypeInitializationChecker).GetMethod("FindDependencies");
internal static int RecordInitializationStart()
{
if (dependencies == null)
{
return 0;
}
Type previousType = null;
foreach (var frame in new StackTrace().GetFrames())
{
var method = frame.GetMethod();
if (method == EntryMethod)
{
break;
}
var declaringType = method.DeclaringType;
if (method == declaringType.TypeInitializer)
{
if (previousType != null)
{
dependencies.Add(new Dependency(declaringType, previousType));
}
previousType = declaringType;
}
}
return 0;
}
public Dependency[] FindDependencies(string name)
{
dependencies = new List<Dependency>();
Type type = typeof(TypeInitializationChecker).Assembly.GetType(name, true);
RuntimeHelpers.RunClassConstructor(type.TypeHandle);
return dependencies.ToArray();
}
internal sealed class Dependency : MarshalByRefObject
{
public string From { get; private set; }
public string To { get; private set; }
internal Dependency(Type from, Type to)
{
From = from.FullName;
To = to.FullName;
}
}
}
TypeInitializationTest
This is within NodaTime.Test:
[TestFixture]
public class TypeInitializationTest
{
[Test]
public void BuildInitializerLoops()
{
Assembly assembly =
typeof(TypeInitializationChecker).Assembly;
var dependencies =
new List<TypeInitializationChecker.Dependency>();
foreach (
var type
in assembly.GetTypes().Where(t => t.FullName.StartsWith(
"NodaTime")))
{
AppDomainSetup setup =
new AppDomainSetup { ApplicationBase = AppDomain.CurrentDomain.BaseDirectory };
AppDomain domain = AppDomain.CreateDomain(
"InitializationTest" + type.Name, AppDomain.CurrentDomain.Evidence, setup);
var helper = (TypeInitializationChecker)domain.CreateInstanceAndUnwrap(assembly.FullName,
typeof(TypeInitializationChecker).FullName);
dependencies.AddRange(helper.FindDependencies(type.FullName));
}
var lookup = dependencies.ToLookup(d => d.From, d => d.To);
foreach (
var group in lookup)
{
Stack<
string> path =
new Stack<
string>();
CheckForCycles(
group.Key, path, lookup);
}
}
private static void CheckForCycles(string next, Stack<string> path, ILookup<string, string> dependencyLookup)
{
if (path.Contains(next))
{
Assert.Fail("Type initializer cycle: {0}-{1}", string.Join("-", path.Reverse().ToArray()), next);
}
path.Push(next);
foreach (var candidate in dependencyLookup[next].Distinct())
{
CheckForCycles(candidate, path, dependencyLookup);
}
path.Pop();
}
}
Jon Skeet's coding blog 