TypeInitializationException Třída

Definice

Obor názvů:

System

Sestavení:

netstandard.dll, System.Runtime.dll

Zdroj:

TypeInitializationException.cs

Výjimka, která je vyvolán jako obálka kolem výjimky vyvolané inicializátorem třídy. Tato třída se nemůže dědit.

public ref class TypeInitializationException sealed : SystemException

public sealed class TypeInitializationException : SystemException

type TypeInitializationException = class
    inherit SystemException

Public NotInheritable Class TypeInitializationException
Inherits SystemException

Dědičnost

Object

Exception

SystemException

TypeInitializationException

Poznámky

Pokud inicializátor třídy selže inicializaci typu, vytvoří se TypeInitializationException a předá se odkaz na výjimku vyvolanou inicializátorem třídy daného typu. Vlastnost InnerExceptionTypeInitializationException 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 odstraňování problémů s ladicím kódem by se výjimka neměla zpracovat v bloku try/catch. 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 konstruktoru TypeInitializationException.

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

Statické konstruktory

Statický konstruktor, pokud existuje, je automaticky volán běhovým prostředím 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 vyvolána výjimka ve statickém konstruktoru, je tato výjimka zabalena do výjimky TypeInitializationException, a typ nelze instancovat.

  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. 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 statickým konstruktorem generovaným kompilátorem. Třída Example obsahuje pole typu static, konkrétně Shared v jazyce C# nebo TestClass v jazyce Visual Basic, které je instancováno 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 konstruktor třídy TestClass 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))
          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()
  

  Zpráva o výjimce zobrazí 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 vyhozena FileNotFoundException, protože běhové prostředí 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()
  

  Note

  V tomto příkladu TypeInitializationException byla vyvolána výjimka, protože se nepodařilo načíst sestavení. 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 který je vyvolán, když hodnota přiřazená k 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;
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()

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 třídy JapaneseCalendar bez parametrů.
• Konstruktor třídy KoreanCalendar bez parametrů.
• Konstruktor třídy TaiwanCalendar bez parametrů.

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.

Konstruktory

Name	Description
TypeInitializationException(String, Exception)	Inicializuje novou instanci třídy s výchozí chybovou TypeInitializationException zprávou, zadaným názvem typu a odkazem na vnitřní výjimku, která je hlavní příčinou této výjimky.

Vlastnosti

Name	Description
Data	Získá kolekci párů klíč/hodnota, které poskytují další uživatelem definované informace o výjimce. (Zděděno od Exception)
HelpLink	Získá nebo nastaví odkaz na soubor nápovědy přidružený k této výjimce. (Zděděno od Exception)
HResult	Získá nebo nastaví HRESULT, kódovanou číselnou hodnotu, která je přiřazena ke konkrétní výjimce. (Zděděno od Exception)
InnerException	Exception Získá instanci, která způsobila aktuální výjimku. (Zděděno od Exception)
Message	Získá zprávu, která popisuje aktuální výjimku. (Zděděno od Exception)
Source	Získá nebo nastaví název aplikace nebo objektu, který způsobuje chybu. (Zděděno od Exception)
StackTrace	Získá řetězcové znázornění okamžitých rámců v zásobníku volání. (Zděděno od Exception)
TargetSite	Získá metodu, která vyvolá aktuální výjimku. (Zděděno od Exception)
TypeName	Získá plně kvalifikovaný název typu, který se nedaří inicializovat.

Metody

Name	Description
Equals(Object)	Určuje, zda je zadaný objekt roven aktuálnímu objektu. (Zděděno od Object)
GetBaseException()	Při přepsání v odvozené třídě vrátí Exception to, že je původní příčinou jedné nebo více následných výjimek. (Zděděno od Exception)
GetHashCode()	Slouží jako výchozí funkce hash. (Zděděno od Object)
GetObjectData(SerializationInfo, StreamingContext)	Zastaralé. SerializationInfo Nastaví objekt s názvem typu a dalšími informacemi o výjimce.
GetType()	Získá typ modulu runtime aktuální instance. (Zděděno od Exception)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (Zděděno od Object)
ToString()	Vytvoří a vrátí řetězcovou reprezentaci aktuální výjimky. (Zděděno od Exception)

Událost

Name	Description
SerializeObjectState	Zastaralé. Nastane, když je výjimka serializována vytvořit objekt stavu výjimky, který obsahuje serializovaná data o výjimce. (Zděděno od Exception)

Viz také

• Exception
• Zpracování a vyvolání výjimek v .NET