An unhandled exception in a static constructor

If an exception is thrown in a static constructor, that exception is wrapped in a TypeInitializationException exception, and the type cannot be instantiated.

What often makes this exception difficult to troubleshoot is that static constructors are not always explicitly defined in source code. A static constructor exists in a type if:

It has been explicitly defined as a member of a type.

The type has static (in C# or F#) or Shared (in Visual Basic) variables that are declared and initialized in a single statement. In this case, the language compiler generates a static constructor for the type. You can inspect it by using a utility such as IL Disassembler . For instance, when the C# and VB compilers compile the following example, they generate the IL for a static constructor that is similar to this:

.method private specialname rtspecialname static   
         void  .cctor() cil managed  
   // Code size       12 (0xc)  
   .maxstack  8  
   IL_0000:  ldc.i4.3  
   IL_0001:  newobj     instance void TestClass::.ctor(int32)  
   IL_0006:  stsfld     class TestClass Example::test  
   IL_000b:  ret  
} // end of method Example::.cctor  
The following example shows a TypeInitializationException exception thrown by a compiler-generated static constructor. The Example class includes a static (in C#) or Shared (in Visual Basic) field of type TestClass that is instantiated by passing a value of 3 to its class constructor.  That value, however, is illegal; only values of 0 or 1 are permitted. As a result, the TestClass class constructor throws an ArgumentOutOfRangeException. Since this exception is not handled, it is wrapped in a TypeInitializationException exception.
using System;
public class Example
   private static TestClass test = new TestClass(3);
   public static void Main()
      Example ex = new Example();
      Console.WriteLine(test.Value);
public class TestClass
   public readonly int Value;
   public TestClass(int value)
      if (value < 0 || value > 1) throw new ArgumentOutOfRangeException();
      Value = value;
// The example displays the following output:
//    Unhandled Exception: System.TypeInitializationException: 
//       The type initializer for 'Example' threw an exception. ---> 
//       System.ArgumentOutOfRangeException: Specified argument was out of the range of valid values.
//       at TestClass..ctor(Int32 value)
//       at Example..cctor()
//       --- End of inner exception stack trace ---
//       at Example.Main()
Public Class Example
   Shared test As New TestClass(3)
   Public Shared Sub Main()
      Dim ex As New Example()
      Console.WriteLine(test.Value)
   End Sub
End Class
Public Class TestClass
   Public ReadOnly Value As Integer
   Public Sub New(value As Integer)
      If value < 0 Or value > 1 Then Throw New ArgumentOutOfRangeException()
      Value = value
   End Sub
End Class
' The example displays the following output:
'    Unhandled Exception: System.TypeInitializationException: 
'       The type initializer for 'Example' threw an exception. ---> 
'       System.ArgumentOutOfRangeException: Specified argument was out of the range of valid values.
'       at TestClass..ctor(Int32 value)
'       at Example..cctor()
'       --- End of inner exception stack trace ---
'       at Example.Main()
Note that the exception message displays information about the InnerException property.
A missing assembly or data file
A common cause of a TypeInitializationException exception is that an assembly or data file that was present in an application's development and test environments is missing from its runtime environment. For example, you can compile the following example to an assembly named Missing1a.dll by using this command-line syntax:
csc -t:library Missing1a.cs  
fsc --target:library Missing1a.fs  
vbc Missing1a.vb -t:library  
using System;
public class InfoModule
   private DateTime firstUse;
   private int ctr = 0;
   public InfoModule(DateTime dat)
      firstUse = dat;
   public int Increment()
      return ++ctr;
   public DateTime GetInitializationTime()
      return firstUse;
open System
type InfoModule(firstUse: DateTime) =
    let mutable ctr = 0
    member _.Increment() =
        ctr <- ctr + 1
    member _.GetInitializationTime() =
        firstUse
Public Class InfoModule
   Private firstUse As DateTime
   Private ctr As Integer = 0
   Public Sub New(dat As DateTime)
      firstUse = dat
   End Sub
   Public Function Increment() As Integer
      ctr += 1
      Return ctr
   End Function
   Public Function GetInitializationTime() As DateTime
      Return firstUse
   End Function
End Class
You can then compile the following example to an executable named Missing1.exe by including a reference to Missing1a.dll:
csc Missing1.cs /r:Missing1a.dll  
vbc Missing1.vb /r:Missing1a.dll  
However, if you rename, move, or delete Missing1a.dll and run the example, it throws a TypeInitializationException exception and displays the output shown in the example.  Note that the exception message includes information about the InnerException property. In this case,  the inner exception is a FileNotFoundException that is thrown because the runtime cannot find the dependent assembly.
using System;
public class Example
   public static void Main()
      Person p = new Person("John", "Doe");
      Console.WriteLine(p);   
public class Person
   static InfoModule infoModule;
   String fName;
   String mName;
   String lName;
   static Person()
      infoModule = new InfoModule(DateTime.UtcNow);
   public Person(String fName, String lName)
      this.fName = fName;
      this.lName = lName;
      infoModule.Increment();
   public override String ToString()
      return String.Format("{0} {1}", fName, lName);
// The example displays the following output if missing1a.dll is renamed or removed:
//    Unhandled Exception: System.TypeInitializationException: 
//       The type initializer for 'Person' threw an exception. ---> 
//       System.IO.FileNotFoundException: Could not load file or assembly 
//       'Missing1a, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null' 
//       or one of its dependencies. The system cannot find the file specified.
//       at Person..cctor()
//       --- End of inner exception stack trace ---
//       at Person..ctor(String fName, String lName)
//       at Example.Main()
open System
type Person(fName, lName) =
    static let infoModule = InfoModule DateTime.UtcNow
    do infoModule.Increment() |> ignore
    override _.ToString() =
        $"{fName} {lName}"
let p = Person("John", "Doe")
printfn $"{p}"
// The example displays the following output if missing1a.dll is renamed or removed:
//    Unhandled Exception: System.TypeInitializationException: 
//       The type initializer for 'Person' threw an exception. ---> 
//       System.IO.FileNotFoundException: Could not load file or assembly 
//       'Missing1a, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null' 
//       or one of its dependencies. The system cannot find the file specified.
//       at Person..cctor()
//       --- End of inner exception stack trace ---
//       at Person..ctor(String fName, String lName)
//       at Example.Main()
Module Example
   Public Sub Main()
      Dim p As New Person("John", "Doe")
      Console.WriteLine(p)   
   End Sub
End Module
Public Class Person
   Shared infoModule As InfoModule
   Dim fName As String
   Dim mName As String
   Dim lName As String
   Shared Sub New()
      infoModule = New InfoModule(DateTime.UtcNow)
   End Sub
   Public Sub New(fName As String, lName As String)
      Me.fName = fName
      Me.lName = lName
      infoModule.Increment()
   End Sub
   Public Overrides Function ToString() As String
      Return String.Format("{0} {1}", fName, lName)
   End Function
End Class
' The example displays the following output if missing1a.dll is renamed or removed:
'    Unhandled Exception: System.TypeInitializationException: 
'       The type initializer for 'Person' threw an exception. ---> 
'       System.IO.FileNotFoundException: Could not load file or assembly 
'       'Missing1a, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null' 
'       or one of its dependencies. The system cannot find the file specified.
'       at Person..cctor()
'       --- End of inner exception stack trace ---
'       at Person..ctor(String fName, String lName)
'       at Example.Main()
In this example, a TypeInitializationException exception was thrown because an assembly could not be loaded. The exception can also be thrown if a static constructor attempts to open a data file, such as a configuration file, an XML file, or a file containing serialized data, that it cannot find.
Regular expression match timeout values
You can set the default timeout value for a regular expression pattern matching operation on a per-application domain basis. The timeout is defined by a specifying a TimeSpan value for the "REGEX_DEFAULT_MATCH_TIMEOUT" property to the  AppDomain.SetData method. The time interval must be a valid TimeSpan object that is greater than zero and less than approximately 24 days. If these requirements are not met, the attempt to set the default timeout value throws an ArgumentOutOfRangeException, which in turn is wrapped in a TypeInitializationException exception.
The following example shows the TypeInitializationException that is thrown when the value assigned to the "REGEX_DEFAULT_MATCH_TIMEOUT" property is invalid. To eliminate the exception, set the"REGEX_DEFAULT_MATCH_TIMEOUT" property to a  TimeSpan value that is greater than zero and less than approximately 24 days.
using System;
using System.Text.RegularExpressions;
public class Example
   public static void Main()
      AppDomain domain = AppDomain.CurrentDomain;
      // Set a timeout interval of -2 seconds.
      domain.SetData("REGEX_DEFAULT_MATCH_TIMEOUT", TimeSpan.FromSeconds(-2));
      Regex rgx = new Regex("[aeiouy]");
      Console.WriteLine("Regular expression pattern: {0}", rgx.ToString());
      Console.WriteLine("Timeout interval for this regex: {0} seconds",
                        rgx.MatchTimeout.TotalSeconds);
// The example displays the following output:
//    Unhandled Exception: System.TypeInitializationException: 
//       The type initializer for 'System.Text.RegularExpressions.Regex' threw an exception. ---> 
//       System.ArgumentOutOfRangeException: Specified argument was out of the range of valid values.
//       Parameter name: AppDomain data 'REGEX_DEFAULT_MATCH_TIMEOUT' contains an invalid value or 
//       object for specifying a default matching timeout for System.Text.RegularExpressions.Regex.
//       at System.Text.RegularExpressions.Regex.InitDefaultMatchTimeout()
//       at System.Text.RegularExpressions.Regex..cctor()
//       --- End of inner exception stack trace ---
//       at System.Text.RegularExpressions.Regex..ctor(String pattern)
//       at Example.Main()
open System
open System.Text.RegularExpressions
let domain = AppDomain.CurrentDomain
// Set a timeout interval of -2 seconds.
domain.SetData("REGEX_DEFAULT_MATCH_TIMEOUT", TimeSpan.FromSeconds -2)
let rgx = Regex "[aeiouy]"
printfn $"Regular expression pattern: {rgx}"
printfn $"Timeout interval for this regex: {rgx.MatchTimeout.TotalSeconds} seconds"
// The example displays the following output:
//    Unhandled Exception: System.TypeInitializationException: 
//       The type initializer for 'System.Text.RegularExpressions.Regex' threw an exception. ---> 
//       System.ArgumentOutOfRangeException: Specified argument was out of the range of valid values.
//       Parameter name: AppDomain data 'REGEX_DEFAULT_MATCH_TIMEOUT' contains an invalid value or 
//       object for specifying a default matching timeout for System.Text.RegularExpressions.Regex.
//       at System.Text.RegularExpressions.Regex.InitDefaultMatchTimeout()
//       at System.Text.RegularExpressions.Regex..cctor()
//       --- End of inner exception stack trace ---
//       at System.Text.RegularExpressions.Regex..ctor(String pattern)
//       at Example.Main()
Imports System.Text.RegularExpressions
Module Example
   Public Sub Main()
      Dim domain As AppDomain = AppDomain.CurrentDomain
      ' Set a timeout interval of -2 seconds.
      domain.SetData("REGEX_DEFAULT_MATCH_TIMEOUT", TimeSpan.FromSeconds(-2))
      Dim rgx As New Regex("[aeiouy]")
      Console.WriteLine("Regular expression pattern: {0}", rgx.ToString())
      Console.WriteLine("Timeout interval for this regex: {0} seconds",
                        rgx.MatchTimeout.TotalSeconds)
   End Sub
End Module
' The example displays the following output:
'    Unhandled Exception: System.TypeInitializationException: 
'       The type initializer for 'System.Text.RegularExpressions.Regex' threw an exception. ---> 
'       System.ArgumentOutOfRangeException: Specified argument was out of the range of valid values.
'       Parameter name: AppDomain data 'REGEX_DEFAULT_MATCH_TIMEOUT' contains an invalid value or 
'       object for specifying a default matching timeout for System.Text.RegularExpressions.Regex.
'       at System.Text.RegularExpressions.Regex.InitDefaultMatchTimeout()
'       at System.Text.RegularExpressions.Regex..cctor()
'       --- End of inner exception stack trace ---
'       at System.Text.RegularExpressions.Regex..ctor(String pattern)
'       at Example.Main()
Calendars and cultural data
If you attempt to instantiate a calendar but the runtime is unable to instantiate  the CultureInfo object that corresponds to that calendar, it throws a TypeInitializationException exception. This exception can be thrown by the following calendar class constructors:
The parameterless constructor of the JapaneseCalendar class.
The parameterless constructor of the KoreanCalendar class.
The parameterless constructor of the TaiwanCalendar class.
Since cultural data for these cultures should be available on all systems, you should rarely, if ever, encounter this exception.
		
Gets a collection of key/value pairs that provide additional user-defined information about the exception.
		(Inherited from Exception)
		
When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions.
		(Inherited from Exception)
		Obsolete. 
When overridden in a derived class, sets the SerializationInfo with information about the exception.
		(Inherited from Exception)
		Obsolete. 
Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.
		(Inherited from Exception)