System.TypeInitializationException – třída

Článek
01/04/2024

Tento článek obsahuje doplňující poznámky k referenční dokumentaci pro toto rozhraní API.

Pokud inicializátor třídy inicializuje typ, TypeInitializationException vytvoří se a předá odkaz na výjimku vyvolanou inicializátorem třídy typu. Vlastnost InnerException TypeInitializationException obsahuje podkladovou výjimku.

Výjimka obvykle TypeInitializationException odráží katastrofický stav (modul runtime nemůže vytvořit instanci typu), který brání pokračování aplikace. Nejčastěji je TypeInitializationException vyvolán v reakci na určitou změnu v prováděcím prostředí aplikace. Kromě případného řešení potíží s kódem ladění by se výjimka neměla zpracovat v try/catch bloku. Místo toho by se měla prozkoumat a odstranit příčina výjimky.

TypeInitializationException používá HODNOTU HRESULT COR_E_TYPEINITIALIZATION, která má hodnotu 0x80131534.

Seznam počátečních hodnot vlastností pro instanci TypeInitializationExceptionnaleznete v TypeInitializationException konstruktorech.

Následující části popisují některé situace, ve kterých TypeInitializationException je vyvolán výjimka.

Statické konstruktory

Statický konstruktor, pokud existuje, je volána automaticky modulem runtime před vytvořením nové instance typu. Statické konstruktory mohou být explicitně definovány vývojářem. Pokud statický konstruktor není explicitně definován, kompilátory ho automaticky vytvoří pro inicializaci libovolného static člena typu (v jazyce C# nebo F#) nebo Shared (v jazyce Visual Basic). Další informace o statických konstruktorech naleznete v tématu Statické konstruktory.

Nejčastěji je vyvolána výjimka, TypeInitializationException když statický konstruktor nemůže vytvořit instanci typu. Vlastnost InnerException označuje, proč statický konstruktor nemohl vytvořit instanci typu. Mezi nejběžnější příčiny TypeInitializationException výjimky patří:

Neošetřená výjimka ve statickém konstruktoru

Pokud je výjimka vyvolána ve statickém konstruktoru, je tato výjimka zabalena do TypeInitializationException výjimky a typ nelze vytvořit instanci.

To, co často ztěžuje řešení potíží, je, že statické konstruktory nejsou vždy explicitně definovány ve zdrojovém kódu. Statický konstruktor existuje v typu, pokud:

Byl explicitně definován jako člen typu.
Typ má static proměnné (v jazyce C# nebo F#) nebo Shared (v jazyce Visual Basic), které jsou deklarovány a inicializovány v jednom příkazu. V tomto případě kompilátor jazyka vygeneruje statický konstruktor pro typ. Můžete ho zkontrolovat pomocí nástroje, jako je IL Disassembler. Když například kompilátory C# a VB zkompilují následující příklad, vygenerují il pro statický konstruktor podobný tomuto:

.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

Následující příklad ukazuje TypeInitializationException výjimku vyvolanou kompilátorem vygenerovaný statický konstruktor. Třída Example obsahuje static pole typu TestClass (v jazyce C#) nebo Shared (v jazyce Visual Basic), které se vytvoří instance předáním hodnoty 3 do konstruktoru třídy. Tato hodnota je však neplatná; Jsou povoleny pouze hodnoty 0 nebo 1. V důsledku toho TestClass konstruktor třídy vyvolá .ArgumentOutOfRangeException Vzhledem k tomu, že tato výjimka není zpracována, je zabalena do TypeInitializationException výjimky.

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()

Všimněte si, že zpráva výjimky zobrazuje informace o InnerException vlastnosti.

Chybějící sestavení nebo datový soubor

Běžnou příčinou TypeInitializationException výjimky je, že v prostředí runtime chybí sestavení nebo datový soubor, který byl přítomný ve vývojovém a testovacím prostředí aplikace. Následující příklad můžete například zkompilovat do sestavení s názvem Missing1a.dll pomocí této syntaxe příkazového řádku:

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

Potom můžete zkompilovat následující příklad do spustitelného souboru s názvem Missing1.exe zahrnutím odkazu na Missing1a.dll:

csc Missing1.cs /r:Missing1a.dll

vbc Missing1.vb /r:Missing1a.dll

Pokud ale přejmenujete, přesunete nebo odstraníte Missing1a.dll a spustíte příklad, vyvolá TypeInitializationException výjimku a zobrazí výstup zobrazený v příkladu. Všimněte si, že zpráva výjimky obsahuje informace o InnerException vlastnosti. V tomto případě je vnitřní výjimka vyvolán FileNotFoundException , protože modul runtime nemůže najít závislé sestavení.

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()

Poznámka:

V tomto příkladu TypeInitializationException byla vyvolán výjimka, protože sestavení nelze načíst. Výjimku lze vyvolat také v případě, že se statický konstruktor pokusí otevřít datový soubor, například konfigurační soubor, soubor XML nebo soubor obsahující serializovaná data, který nemůže najít.

Hodnoty časového limitu regulárního výrazu odpovídají hodnotám časového limitu.

Výchozí hodnotu časového limitu pro operaci porovnávání vzorů regulárních výrazů můžete nastavit pro každou doménu aplikace. Časový limit je definován zadáním TimeSpan hodnoty vlastnosti "REGEX_DEFAULT_MATCH_TIMEOUT" metody AppDomain.SetData . Časový interval musí být platný TimeSpan objekt, který je větší než nula a menší než přibližně 24 dnů. Pokud tyto požadavky nejsou splněny ArgumentOutOfRangeException, pokus o nastavení výchozí hodnoty časového limitu vyvolá výjimku, která je zase zabalena do TypeInitializationException výjimky.

Následující příklad ukazuje TypeInitializationException , že je vyvolán, když hodnota přiřazená vlastnosti "REGEX_DEFAULT_MATCH_TIMEOUT" je neplatná. Chcete-li odstranit výjimku, nastavte vlastnost "REGEX_DEFAULT_MATCH_TIMEOUT" na TimeSpan hodnotu, která je větší než nula a menší než přibližně 24 dní.

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()

Kalendáře a kulturní data

Pokud se pokusíte vytvořit instanci kalendáře, ale modul runtime nemůže vytvořit instanci objektu CultureInfo , který odpovídá danému kalendáři, vyvolá TypeInitializationException výjimku. Tuto výjimku může vyvolat následující konstruktory třídy kalendáře:

Konstruktor JapaneseCalendar bez parametrů třídy.
Konstruktor KoreanCalendar bez parametrů třídy.
Konstruktor TaiwanCalendar bez parametrů třídy.

Vzhledem k tomu, že kulturní data pro tyto jazykové verze by měla být k dispozici ve všech systémech, měli byste na tuto výjimku narazit zřídka, pokud vůbec někdy.

Sdílet prostřednictvím

System.TypeInitializationException – třída

Statické konstruktory

Hodnoty časového limitu regulárního výrazu odpovídají hodnotám časového limitu.

Kalendáře a kulturní data

Další materiály