TypeInitializationException Classe

Definizione

public ref class TypeInitializationException sealed : Exception

public ref class TypeInitializationException sealed : SystemException

public sealed class TypeInitializationException : Exception

public sealed class TypeInitializationException : SystemException

[System.Serializable]
public sealed class TypeInitializationException : SystemException

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class TypeInitializationException : SystemException

type TypeInitializationException = class
    inherit Exception

type TypeInitializationException = class
    inherit SystemException

[<System.Serializable>]
type TypeInitializationException = class
    inherit SystemException

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type TypeInitializationException = class
    inherit SystemException

Public NotInheritable Class TypeInitializationException
Inherits Exception

Public NotInheritable Class TypeInitializationException
Inherits SystemException

Ereditarietà

Object

Exception

TypeInitializationException

Ereditarietà

Object

Exception

SystemException

TypeInitializationException

Attributi

SerializableAttribute ComVisibleAttribute

Commenti

Quando un inizializzatore di classe non riesce a inizializzare un tipo, viene creato un oggetto TypeInitializationException e passato un riferimento all'eccezione generata dall'inizializzatore di classe 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, a meno che non sia necessario per la risoluzione dei problemi del codice di debug, l'eccezione non dovrebbe essere gestita in un blocco try/catch. 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 dei valori iniziali delle proprietà per un'istanza di TypeInitializationException, consultare i costruttori di TypeInitializationException.

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 sollevata un'eccezione in un costruttore statico, l'eccezione viene incapsulata 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 . 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 campo static (in C#) o Shared (in Visual Basic) di tipo TestClass, istanziato passando il valore 3 al suo costruttore di classe. Tale valore, tuttavia, è illegale; sono consentiti solo i valori 0 o 1. Di conseguenza, il costruttore della classe TestClass genera un'eccezione ArgumentOutOfRangeException. Poiché questa eccezione non viene gestita, viene incapsulata 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))
          End If
          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()
  

  Il messaggio di eccezione visualizza informazioni sulla InnerException proprietà .

• Un componente o un file 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()
  

  Note

  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 è definito specificando un valore TimeSpan per la proprietà "REGEX_DEFAULT_MATCH_TIMEOUT" nel metodo AppDomain.SetData. 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 ArgumentOutOfRangeException, che a sua volta viene inserito in un'eccezione TypeInitializationException.

Nell'esempio seguente viene illustrata l'eccezione TypeInitializationException che viene 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;
using static System.Net.Mime.MediaTypeNames;

public class RegexEx1
{
    public static void Run()
    {
        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: {rgx.ToString()}");
        Console.WriteLine($"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 'AppDomain data 'REGEX_DEFAULT_MATCH_TIMEOUT' contains the invalid value or object
//       '-00:00:02' 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, CultureInfo culture)
//       at RegexEx1.Run()

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 culture devono essere disponibili su tutti i sistemi, dovresti raramente, se non mai, riscontrare questa eccezione.

Vedi anche

• Exception
• Gestione e generazione di eccezioni in .NET