Classe System.TypeInitializationException

Articolo
01/04/2024

Questo articolo fornisce osservazioni supplementari alla documentazione di riferimento per questa API.

Quando un inizializzatore di classi non inizializza un tipo, viene creata un'eccezione TypeInitializationException che viene passata come riferimento all'eccezione generata dall'inizializzatore di classi del tipo. La InnerException proprietà di TypeInitializationException contiene l'eccezione sottostante.

In genere, l'eccezione TypeInitializationException riflette una condizione irreversibile (il runtime non è in grado di creare un'istanza di un tipo) che impedisce a un'applicazione di continuare. In genere, TypeInitializationException viene generata in risposta ad alcune modifiche nell'ambiente in esecuzione dell'applicazione. Di conseguenza, diversamente da possibilmente per la risoluzione dei problemi del codice di debug, l'eccezione non deve essere gestita in un try/catch blocco. Al contrario, la causa dell'eccezione deve essere analizzata ed eliminata.

TypeInitializationException usa HRESULT COR_E_TYPEINITIALIZATION, che ha il valore 0x80131534.

Per un elenco di valori di proprietà iniziali per un'istanza di TypeInitializationException, vedere il TypeInitializationException costruttori.

Le sezioni seguenti descrivono alcune delle situazioni in cui viene generata un'eccezione TypeInitializationException .

Costruttori statici

Un costruttore statico, se presente, viene chiamato automaticamente dal runtime prima di creare una nuova istanza di un tipo. I costruttori statici possono essere definiti in modo esplicito da uno sviluppatore. Se un costruttore statico non è definito in modo esplicito, i compilatori ne creano automaticamente uno per inizializzare qualsiasi static membro (in C# o F#) o Shared (in Visual Basic) del tipo. Per altre informazioni sui costruttori statici, vedere Costruttori statici.

In genere, viene generata un'eccezione TypeInitializationException quando un costruttore statico non è in grado di creare un'istanza di un tipo. La InnerException proprietà indica il motivo per cui il costruttore statico non è riuscito a creare un'istanza del tipo. Alcune delle cause più comuni di un'eccezione TypeInitializationException sono:

Eccezione non gestita in un costruttore statico

Se viene generata un'eccezione in un costruttore statico, tale eccezione viene sottoposta a wrapping in un'eccezione TypeInitializationException e non è possibile creare un'istanza del tipo.

Ciò che spesso rende difficile risolvere questo problema è che i costruttori statici non sono sempre definiti in modo esplicito nel codice sorgente. Un costruttore statico esiste in un tipo se:

È stato definito in modo esplicito come membro di un tipo.
Il tipo include static variabili (in C# o F#) o Shared (in Visual Basic) dichiarate e inizializzate in una singola istruzione. In questo caso, il compilatore del linguaggio genera un costruttore statico per il tipo . È possibile esaminarlo usando un'utilità come il disassembler IL. Ad esempio, quando i compilatori C# e VB compilano l'esempio seguente, generano il codice IL per un costruttore statico simile al seguente:

.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

Nell'esempio seguente viene illustrata un'eccezione TypeInitializationException generata da un costruttore statico generato dal compilatore. La Example classe include un static campo (in C#) o Shared (in Visual Basic) di tipo di cui TestClass viene creata un'istanza passando un valore pari a 3 al relativo costruttore di classe. Tale valore, tuttavia, è illegale; sono consentiti solo i valori 0 o 1. Di conseguenza, il costruttore della TestClass classe genera un'eccezione ArgumentOutOfRangeException. Poiché questa eccezione non viene gestita, viene sottoposta a wrapping in un'eccezione TypeInitializationException .

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(nameof(value));
      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 Example1
    Shared test As New TestClass(3)

    Public Shared Sub Main()
        Dim ex As New Example1()
        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(NameOf(value))
        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()

Si noti che il messaggio di eccezione visualizza informazioni sulla InnerException proprietà .

Un assembly o un file di dati mancante

Una causa comune di un'eccezione TypeInitializationException è che un assembly o un file di dati presente negli ambienti di sviluppo e test di un'applicazione non è presente nell'ambiente di runtime. Ad esempio, è possibile compilare l'esempio seguente in un assembly denominato Missing1a.dll usando questa sintassi della riga di comando:

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
        ctr
   
    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

È quindi possibile compilare l'esempio seguente in un eseguibile denominato Missing1.exe includendo un riferimento a Missing1a.dll:

csc Missing1.cs /r:Missing1a.dll

vbc Missing1.vb /r:Missing1a.dll

Tuttavia, se si rinomina, si sposta o si elimina Missing1a.dll ed si esegue l'esempio, viene generata un'eccezione TypeInitializationException e viene visualizzato l'output illustrato nell'esempio. Si noti che il messaggio di eccezione include informazioni sulla InnerException proprietà . In questo caso, l'eccezione interna è un'eccezione FileNotFoundException generata perché il runtime non riesce a trovare l'assembly dipendente.

using System;

public class MissingEx1
{
    public static void Main()
    {
        Person p = new Person("John", "Doe");
        Console.WriteLine(p);
    }
}

public class Person
{
    static readonly InfoModule s_infoModule;

    readonly string _fName;
    readonly string _lName;

    static Person()
    {
        s_infoModule = new InfoModule(DateTime.UtcNow);
    }

    public Person(string fName, string lName)
    {
        _fName = fName;
        _lName = lName;
        s_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 Example3
    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()

Nota

In questo esempio è stata generata un'eccezione TypeInitializationException perché non è stato possibile caricare un assembly. L'eccezione può essere generata anche se un costruttore statico tenta di aprire un file di dati, ad esempio un file di configurazione, un file XML o un file contenente dati serializzati, che non è possibile trovare.

Valori di timeout delle espressioni regolari

È possibile impostare il valore di timeout predefinito per un'operazione di corrispondenza dei criteri di espressione regolare per ogni dominio applicazione. Il timeout viene definito da un oggetto che specifica un TimeSpan valore per la proprietà "REGEX_DEFAULT_MATCH_TIMEOUT" al AppDomain.SetData metodo . L'intervallo di tempo deve essere un oggetto valido TimeSpan maggiore di zero e minore di circa 24 giorni. Se questi requisiti non vengono soddisfatti, il tentativo di impostare il valore di timeout predefinito genera un ArgumentOutOfRangeExceptionoggetto , che a sua volta viene sottoposto a wrapping in un'eccezione TypeInitializationException .

Nell'esempio seguente viene illustrato l'eccezione TypeInitializationException generata quando il valore assegnato alla proprietà "REGEX_DEFAULT_MATCH_TIMEOUT" non è valido. Per eliminare l'eccezione, impostare la proprietà "REGEX_DEFAULT_MATCH_TIMEOUT" su un TimeSpan valore maggiore di zero e inferiore a circa 24 giorni.

using System;
using System.Text.RegularExpressions;

public class RegexEx1
{
    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 Example4
    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()

Calendari e dati culturali

Se si tenta di creare un'istanza di un calendario ma il runtime non è in grado di creare un'istanza dell'oggetto CultureInfo che corrisponde a tale calendario, genera un'eccezione TypeInitializationException . Questa eccezione può essere generata dai costruttori di classi del calendario seguenti:

Costruttore senza parametri della JapaneseCalendar classe .
Costruttore senza parametri della KoreanCalendar classe .
Costruttore senza parametri della TaiwanCalendar classe .

Poiché i dati culturali per queste impostazioni cultura devono essere disponibili in tutti i sistemi, è consigliabile raramente, se mai, riscontrare questa eccezione.

Condividi tramite

Classe System.TypeInitializationException

Costruttori statici

Valori di timeout delle espressioni regolari

Calendari e dati culturali

Risorse aggiuntive