TypeInitializationException Klasse

Definition

Die Ausnahme, die als Wrapper um die von dieser Klasseninitialisierung ausgelöste Ausnahme ausgelöst wird.The exception that is thrown as a wrapper around the exception thrown by the class initializer. Diese Klasse kann nicht vererbt werden.This class cannot be inherited.

public ref class TypeInitializationException sealed : SystemException
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public sealed class TypeInitializationException : SystemException
type TypeInitializationException = class
    inherit SystemException
Public NotInheritable Class TypeInitializationException
Inherits SystemException
Vererbung
TypeInitializationException
Attribute

Hinweise

Wenn die Initialisierung eines Typs durch eine Klasseninitialisierung fehlschlägt, wird eine TypeInitializationException erstellt. Dieser Ausnahme wird dann ein Verweis auf die Ausnahme übergeben, die durch die Klasseninitialisierung des Typs ausgelöst wurde.When a class initializer fails to initialize a type, a TypeInitializationException is created and passed a reference to the exception thrown by the type's class initializer. Die InnerException -Eigenschaft TypeInitializationException von enthält die zugrunde liegende Ausnahme.The InnerException property of TypeInitializationException holds the underlying exception.

In der Regel TypeInitializationException spiegelt die Ausnahme eine katastrophale Bedingung wider (die Laufzeit kann einen Typ nicht instanziieren), wodurch verhindert wird, dass die Anwendung fortgesetzt wird.Typically, the TypeInitializationException exception reflects a catastrophic condition (the runtime is unable to instantiate a type) that prevents an application from continuing. In den meisten Fällen TypeInitializationException wird der als Reaktion auf eine Änderung in der Ausführungsumgebung der Anwendung ausgelöst.Most commonly, the TypeInitializationException is thrown in response to some change in the executing environment of the application. Folglich sollte die Ausnahme nicht in einem try / catch -Block behandelt werden, außer möglicherweise für die Problembehandlung von Debugcode.Consequently, other than possibly for troubleshooting debug code, the exception should not be handled in a try/catch block. Stattdessen sollte die Ursache der Ausnahme untersucht und entfernt werden.Instead, the cause of the exception should be investigated and eliminated.

TypeInitializationExceptionverwendet das HRESULT-COR_E_TYPEINITIALIZATION, das den Wert 0x80131534 aufweist.TypeInitializationException uses the HRESULT COR_E_TYPEINITIALIZATION, which has the value 0x80131534.

Eine Liste der anfänglichen Eigenschaftswerte für eine Instanz von TypeInitializationException, finden Sie unter den TypeInitializationException Konstruktoren.For a list of initial property values for an instance of TypeInitializationException, see the TypeInitializationException constructors.

In den folgenden Abschnitten werden einige Situationen beschrieben, in denen TypeInitializationException eine-Ausnahme ausgelöst wird.The following sections describe some of the situations in which a TypeInitializationException exception is thrown.

Statische Konstruktoren und TypeInitializationExceptionStatic constructors and the TypeInitializationException

Wenn ein statischer Konstruktor vorhanden ist, wird er automatisch von der Laufzeit aufgerufen, bevor eine neue Instanz eines Typs erstellt wird.A static constructor, if one exists, is called automatically by the runtime before creating a new instance of a type. Statische Konstruktoren können von einem Entwickler explizit definiert werden.Static constructors can be explicitly defined by a developer. Wenn ein statischer Konstruktor nicht explizit definiert ist, erstellen Compiler automatisch einen, um beliebige static (in C#) oder Shared (in Visual Basic) Member des Typs zu initialisieren.If a static constructor is not explicitly defined, compilers automatically create one to initialize any static (in C#) or Shared (in Visual Basic) members of the type. Weitere Informationen zu statischen Konstruktoren finden Sie unter statische Konstruktoren.For more information on static constructors, see Static Constructors.

In den meisten Fällen TypeInitializationException wird eine-Ausnahme ausgelöst, wenn ein statischer Konstruktor einen Typ nicht instanziieren kann.Most commonly, a TypeInitializationException exception is thrown when a static constructor is unable to instantiate a type. Die InnerException -Eigenschaft gibt an, warum der statische Konstruktor den Typ nicht instanziieren konnte.The InnerException property indicates why the static constructor was unable to instantiate the type. Einige der häufigsten Gründe für eine TypeInitializationException -Ausnahme sind:Some of the more common causes of a TypeInitializationException exception are:

  • Eine nicht behandelte Ausnahme in einem statischen Konstruktor.An unhandled exception in a static constructor

    Wenn in einem statischen Konstruktor eine Ausnahme ausgelöst wird, wird diese Ausnahme in eine TypeInitializationException -Ausnahme umgerückt, und der-Typ kann nicht instanziiert werden.If an exception is thrown in a static constructor, that exception is wrapped in a TypeInitializationException exception, and the type cannot be instantiated.

    Diese Ausnahme ist häufig schwer zu beheben, da statische Konstruktoren nicht immer explizit im Quellcode definiert werden.What often makes this exception difficult to troubleshoot is that static constructors are not always explicitly defined in source code. Ein statischer Konstruktor ist in einem Typ vorhanden, wenn Folgendes vorliegt:A static constructor exists in a type if:

    • Es wurde explizit als Member eines Typs definiert.It has been explicitly defined as a member of a type.

    • Der Typ verfügt static über ( C#in) Shared oder (in Visual Basic) Variablen, die in einer einzelnen Anweisung deklariert und initialisiert werden.The type has static (in C#) or Shared (in Visual Basic) variables that are declared and initialized in a single statement. In diesem Fall generiert der sprach Compiler einen statischen Konstruktor für den Typ.In this case, the language compiler generates a static constructor for the type. Sie können ihn mithilfe eines Hilfsprogramms wie IL Disassemblerüberprüfen.You can inspect it by using a utility such as IL Disassembler. Wenn z. b. C# der-und VB-Compiler das folgende Beispiel kompiliert, generieren Sie die Il für einen statischen Konstruktor, der in etwa wie folgt aussieht:For instance, when the C# and VB compilers compile the following example, they generate the IL for a static constructor that is similar to this:

    .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  
    

    Das folgende Beispiel zeigt eine TypeInitializationException -Ausnahme, die von einem vom Compiler generierten statischen Konstruktor ausgelöst wird.The following example shows a TypeInitializationException exception thrown by a compiler-generated static constructor. Die Example -Klasse enthält static ein- C#Feld ( Shared in) oder (in Visual Basic) TestClass vom Typ, das instanziiert wird, indem der Wert 3 an den zugehörigen Klassenkonstruktor übergeben wird.The Example class includes a static (in C#) or Shared (in Visual Basic) field of type TestClass that is instantiated by passing a value of 3 to its class constructor. Dieser Wert ist jedoch unzulässig. nur die Werte 0 oder 1 sind zulässig.That value, however, is illegal; only values of 0 or 1 are permitted. Folglich löst der TestClass Klassenkonstruktor einen ArgumentOutOfRangeExceptionaus.As a result, the TestClass class constructor throws an ArgumentOutOfRangeException. Da diese Ausnahme nicht behandelt wird, wird Sie in eine TypeInitializationException -Ausnahme umschließt.Since this exception is not handled, it is wrapped in a TypeInitializationException exception.

    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();
          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 Example
       Shared test As New TestClass(3)
       
       Public Shared Sub Main()
          Dim ex As New Example()
          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()
          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()
    

    Beachten Sie, dass in der Ausnahme Meldung Informationen InnerException zur-Eigenschaft angezeigt werden.Note that the exception message displays information about the InnerException property.

  • Eine fehlende Assembly oder DatendateiA missing assembly or data file

    Eine häufige Ursache für eine TypeInitializationException -Ausnahme ist, dass eine Assembly oder Datendatei, die in den Entwicklungs-und Testumgebungen einer Anwendung vorhanden war, in der Laufzeitumgebung fehlt.A common cause of a TypeInitializationException exception is that an assembly or data file that was present in an application's development and test environments is missing from its runtime environment. Beispielsweise können Sie das folgende Beispiel mit der folgenden Befehlszeilen Syntax in eine Assembly mit dem Namen Missing1a. dll kompilieren:For example, you can compile the following example to an assembly named Missing1a.dll by using this command-line syntax:

    csc -t:library Missing1a.cs  
    
    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;
       }
    }
    
    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
    

    Anschließend können Sie das folgende Beispiel in eine ausführbare Datei mit dem Namen Missing1. exe kompilieren, indem Sie einen Verweis auf Missing1a. dll einschließen:You can then compile the following example to an executable named Missing1.exe by including a reference to Missing1a.dll:

    csc Missing1.cs /r:Missing1a.dll  
    
    vbc Missing1.vb /r:Missing1a.dll  
    

    Wenn Sie jedoch Missing1a. dll umbenennen, verschieben oder löschen und das Beispiel ausführen, wird eine TypeInitializationException -Ausnahme ausgelöst und die im Beispiel gezeigte Ausgabe angezeigt.However, if you rename, move, or delete Missing1a.dll and run the example, it throws a TypeInitializationException exception and displays the output shown in the example. Beachten Sie, dass die Ausnahme Meldung Informationen über InnerException die Eigenschaft enthält.Note that the exception message includes information about the InnerException property. In diesem Fall handelt es sich bei der inneren FileNotFoundException Ausnahme um eine, die ausgelöst wird, da die Runtime die abhängige Assembly nicht finden kann.In this case, the inner exception is a FileNotFoundException that is thrown because the runtime cannot find the dependent assembly.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          Person p = new Person("John", "Doe");
          Console.WriteLine(p);   
       }
    }
    
    public class Person
    {
       static InfoModule infoModule;
       
       String fName;
       String mName;
       String lName;
       
       static Person()
       {
          infoModule = new InfoModule(DateTime.UtcNow);
       }
       
       public Person(String fName, String lName)
       {
          this.fName = fName;
          this.lName = lName;
          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()
    
    Module Example
       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()
    

    Hinweis

    In diesem Beispiel wurde eine TypeInitializationException -Ausnahme ausgelöst, weil eine Assembly nicht geladen werden konnte.In this example, a TypeInitializationException exception was thrown because an assembly could not be loaded. Die Ausnahme kann auch ausgelöst werden, wenn ein statischer Konstruktor versucht, eine Datendatei zu öffnen, z. b. eine Konfigurationsdatei, eine XML-Datei oder eine Datei mit serialisierten Daten, die nicht gefunden werden kann.The exception can also be thrown if a static constructor attempts to open a data file, such as a configuration file, an XML file, or a file containing serialized data, that it cannot find.

Vergleichs Timeout Werte für reguläre AusdrückeRegular expression match timeout values

Sie können den Standard Timeout Wert für einen Vorgang eines Musters für reguläre Ausdrücke auf Anwendungs Basis festlegen.You can set the default timeout value for a regular expression pattern matching operation on a per-application domain basis. Das Timeout wird durch einen definiert, der TimeSpan einen Wert für die Eigenschaft "REGEX_DEFAULT_MATCH_TIMEOUT" der AppDomain.SetData Methode angibt.The timeout is defined by a specifying a TimeSpan value for the "REGEX_DEFAULT_MATCH_TIMEOUT" property to the AppDomain.SetData method. Das Zeitintervall muss ein gültiges TimeSpan -Objekt sein, das größer als 0 (null) und kleiner als ungefähr 24 Tage ist.The time interval must be a valid TimeSpan object that is greater than zero and less than approximately 24 days. Wenn diese Anforderungen nicht erfüllt werden, löst der Versuch, den Standard Timeout Wert festzulegen ArgumentOutOfRangeException, eine aus, die wiederum in eine TypeInitializationException -Ausnahme umschließt.If these requirements are not met, the attempt to set the default timeout value throws an ArgumentOutOfRangeException, which in turn is wrapped in a TypeInitializationException exception.

Das folgende Beispiel zeigt das TypeInitializationException -Objekt, das ausgelöst wird, wenn der Wert, der der Eigenschaft "REGEX_DEFAULT_MATCH_TIMEOUT" zugewiesen ist, ungültig ist.The following example shows the TypeInitializationException that is thrown when the value assigned to the "REGEX_DEFAULT_MATCH_TIMEOUT" property is invalid. Um die Ausnahme auszuschließen, legen Sie die Eigenschaft "REGEX_DEFAULT_MATCH_TIMEOUT" auf TimeSpan einen Wert fest, der größer als 0 (null) und kleiner als ungefähr 24 Tage ist.To eliminate the exception, set the"REGEX_DEFAULT_MATCH_TIMEOUT" property to a TimeSpan value that is greater than zero and less than approximately 24 days.

using System;
using System.Text.RegularExpressions;

public class Example
{
   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()
Imports System.Text.RegularExpressions

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

Kalender und Kultur DatenCalendars and cultural data

Wenn Sie versuchen, einen Kalender zu instanziieren, aber die Laufzeit das CultureInfo Objekt, das diesem Kalender entspricht, nicht instanziieren kann, wird eine TypeInitializationException -Ausnahme ausgelöst.If you attempt to instantiate a calendar but the runtime is unable to instantiate the CultureInfo object that corresponds to that calendar, it throws a TypeInitializationException exception. Diese Ausnahme kann durch die folgenden kalenderklassenkonstruktoren ausgelöst werden:This exception can be thrown by the following calendar class constructors:

Da kulturelle Daten für diese Kulturen auf allen Systemen verfügbar sein sollten, sollte diese Ausnahme in seltenen Fällen auftreten.Since cultural data for these cultures should be available on all systems, you should rarely, if ever, encounter this exception.

Konstruktoren

TypeInitializationException(String, Exception)

Initialisiert eine neue Instanz der TypeInitializationException-Klasse mit einer angegebenen Fehlermeldung, dem angegebenen Typnamen und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat.Initializes a new instance of the TypeInitializationException class with the default error message, the specified type name, and a reference to the inner exception that is the root cause of this exception.

Eigenschaften

Data

Ruft eine Auflistung von Schlüssel-Wert-Paaren ab, die zusätzliche benutzerdefinierte Informationen über die Ausnahme bereitstellen.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Geerbt von Exception)
HelpLink

Ruft einen Link zur Hilfedatei ab, die dieser Ausnahme zugeordnet ist, oder legt einen Link fest.Gets or sets a link to the help file associated with this exception.

(Geerbt von Exception)
HResult

Ruft HRESULT ab oder legt HRESULT fest. Dies ist ein codierter Wert, der einer bestimmten Ausnahme zugeordnet ist.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Geerbt von Exception)
InnerException

Ruft die Exception-Instanz ab, die die aktuelle Ausnahme verursacht hat.Gets the Exception instance that caused the current exception.

(Geerbt von Exception)
Message

Ruft eine Meldung ab, die die aktuelle Ausnahme beschreibt.Gets a message that describes the current exception.

(Geerbt von Exception)
Source

Gibt den Namen der Anwendung oder des Objekts zurück, die bzw. das den Fehler verursacht hat, oder legt diesen fest.Gets or sets the name of the application or the object that causes the error.

(Geerbt von Exception)
StackTrace

Ruft eine Zeichenfolgendarstellung der unmittelbaren Frames in der Aufrufliste ab.Gets a string representation of the immediate frames on the call stack.

(Geerbt von Exception)
TargetSite

Ruft die Methode ab, die die aktuelle Ausnahme auslöst.Gets the method that throws the current exception.

(Geerbt von Exception)
TypeName

Ruft den voll gekennzeichneten Namen des Typs ab, der nicht initialisiert werden kann.Gets the fully qualified name of the type that fails to initialize.

Methoden

Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Geerbt von Object)
GetBaseException()

Gibt beim Überschreiben in einer abgeleiteten Klasse eine Exception zurück, die die ursprüngliche Ursache für eine oder mehrere nachfolgende Ausnahmen ist.When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions.

(Geerbt von Exception)
GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

(Geerbt von Object)
GetObjectData(SerializationInfo, StreamingContext)

Legt das SerializationInfo-Objekt mit dem Typnamen und zusätzlichen Informationen zur Ausnahme fest.Sets the SerializationInfo object with the type name and additional exception information.

GetType()

Ruft den Laufzeittyp der aktuellen Instanz ab.Gets the runtime type of the current instance.

(Geerbt von Exception)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Geerbt von Object)
ToString()

Erstellt eine Zeichenfolgendarstellung der aktuellen Ausnahme und gibt diese zurück.Creates and returns a string representation of the current exception.

(Geerbt von Exception)

Ereignisse

SerializeObjectState

Tritt auf, wenn eine Ausnahme serialisiert wird, um ein Ausnahmezustandsobjekt mit serialisierten Daten über die Ausnahme zu erstellen.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Geerbt von Exception)

Gilt für:

Siehe auch