Condividi tramite


Classe System.TypeInitializationException

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:

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