TypeInitializationException Classe

Définition

Exception levée comme wrapper pour l'exception levée par l'initialiseur de classe.The exception that is thrown as a wrapper around the exception thrown by the class initializer. Cette classe ne peut pas être héritée.This class cannot be inherited.

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
Héritage
TypeInitializationException
Héritage
TypeInitializationException
Attributs

Remarques

Lorsqu'un initialiseur de classe ne réussit pas à initialiser un type, Lorsqu'un initialiseur de classe n'arrive pas à initialiser un type, une TypeInitializationException est créée et passe une référence à l'exception levée par l'initialiseur de classe du type.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. La InnerException propriété de TypeInitializationException contient l’exception sous-jacente.The InnerException property of TypeInitializationException holds the underlying exception.

En règle générale, l' TypeInitializationException exception reflète une condition catastrophique (le runtime ne peut pas instancier un type) qui empêche une application de se poursuivre.Typically, the TypeInitializationException exception reflects a catastrophic condition (the runtime is unable to instantiate a type) that prevents an application from continuing. Le plus souvent, l' TypeInitializationException exception est levée en réponse à une modification de l’environnement d’exécution de l’application.Most commonly, the TypeInitializationException is thrown in response to some change in the executing environment of the application. Par conséquent, hormis le dépannage du code de débogage, l’exception ne doit pas être gérée dans un try / catch bloc.Consequently, other than possibly for troubleshooting debug code, the exception should not be handled in a try/catch block. Au lieu de cela, la cause de l’exception doit être examinée et éliminée.Instead, the cause of the exception should be investigated and eliminated.

TypeInitializationException utilise le COR_E_TYPEINITIALIZATION HRESULT, qui a la valeur 0x80131534.TypeInitializationException uses the HRESULT COR_E_TYPEINITIALIZATION, which has the value 0x80131534.

Pour obtenir la liste des valeurs initiales des propriétés d’une instance de TypeInitializationException, consultez le TypeInitializationException constructeurs.For a list of initial property values for an instance of TypeInitializationException, see the TypeInitializationException constructors.

Les sections suivantes décrivent certaines situations dans lesquelles une TypeInitializationException exception est levée.The following sections describe some of the situations in which a TypeInitializationException exception is thrown.

Constructeurs statiques et TypeInitializationExceptionStatic constructors and the TypeInitializationException

Un constructeur statique, le cas échéant, est appelé automatiquement par le runtime avant la création d’une nouvelle instance d’un type.A static constructor, if one exists, is called automatically by the runtime before creating a new instance of a type. Les constructeurs statiques peuvent être définis explicitement par un développeur.Static constructors can be explicitly defined by a developer. Si un constructeur statique n’est pas défini explicitement, les compilateurs en créent automatiquement un pour initialiser tous les static membres (en C#) ou Shared (dans Visual Basic) du type.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. Pour plus d’informations sur les constructeurs statiques, consultez constructeurs statiques.For more information on static constructors, see Static Constructors.

En règle générale, une TypeInitializationException exception est levée lorsqu’un constructeur statique ne peut pas instancier un type.Most commonly, a TypeInitializationException exception is thrown when a static constructor is unable to instantiate a type. La InnerException propriété indique la raison pour laquelle le constructeur statique n’a pas pu instancier le type.The InnerException property indicates why the static constructor was unable to instantiate the type. Voici quelques-unes des causes les plus courantes d’une TypeInitializationException exception :Some of the more common causes of a TypeInitializationException exception are:

  • Exception non gérée dans un constructeur statiqueAn unhandled exception in a static constructor

    Si une exception est levée dans un constructeur statique, cette exception est encapsulée dans une TypeInitializationException exception, et le type ne peut pas être instancié.If an exception is thrown in a static constructor, that exception is wrapped in a TypeInitializationException exception, and the type cannot be instantiated.

    Ce qui rend souvent cette exception difficile à dépanner est que les constructeurs statiques ne sont pas toujours définis explicitement dans le code source.What often makes this exception difficult to troubleshoot is that static constructors are not always explicitly defined in source code. Un constructeur statique existe dans un type si :A static constructor exists in a type if:

    • Il a été explicitement défini en tant que membre d’un type.It has been explicitly defined as a member of a type.

    • Le type a des static variables (en C#) ou Shared (dans Visual Basic) qui sont déclarées et initialisées dans une instruction unique.The type has static (in C#) or Shared (in Visual Basic) variables that are declared and initialized in a single statement. Dans ce cas, le compilateur de langage génère un constructeur statique pour le type.In this case, the language compiler generates a static constructor for the type. Vous pouvez l’inspecter à l’aide d’un utilitaire tel que le désassembleur il.You can inspect it by using a utility such as IL Disassembler. Par exemple, lorsque les compilateurs C# et VB compilent l’exemple suivant, ils génèrent le langage intermédiaire pour un constructeur statique qui est semblable à ce qui suit :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  
    

    L’exemple suivant montre une TypeInitializationException exception levée par un constructeur statique généré par le compilateur.The following example shows a TypeInitializationException exception thrown by a compiler-generated static constructor. La Example classe comprend un static champ (en C#) ou Shared (dans Visual Basic) de type TestClass instancié en passant une valeur de 3 à son constructeur de classe.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. Toutefois, cette valeur n’est pas conforme ; seules les valeurs 0 ou 1 sont autorisées.That value, however, is illegal; only values of 0 or 1 are permitted. Par conséquent, le TestClass constructeur de classe lève une exception ArgumentOutOfRangeException .As a result, the TestClass class constructor throws an ArgumentOutOfRangeException. Étant donné que cette exception n’est pas gérée, elle est encapsulée dans une TypeInitializationException exception.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()
    

    Notez que le message d’exception affiche des informations sur la InnerException propriété.Note that the exception message displays information about the InnerException property.

  • Un assembly ou un fichier de données manquantA missing assembly or data file

    L’une des causes courantes d’une TypeInitializationException exception est qu’un assembly ou un fichier de données qui était présent dans les environnements de développement et de test d’une application ne se trouve pas dans son environnement d’exécution.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. Par exemple, vous pouvez compiler l’exemple suivant dans un assembly nommé Missing1a.dll à l’aide de la syntaxe de ligne de commande suivante :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
    

    Vous pouvez ensuite compiler l’exemple suivant sur un exécutable nommé Missing1.exe en incluant une référence à Missing1a.dll :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  
    

    Toutefois, si vous renommez, déplacez ou supprimez Missing1a.dll et exécutez l’exemple, il lève une TypeInitializationException exception et affiche la sortie indiquée dans l’exemple.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. Notez que le message d’exception contient des informations sur la InnerException propriété.Note that the exception message includes information about the InnerException property. Dans ce cas, l’exception interne est une exception FileNotFoundException qui est levée parce que le runtime ne peut pas trouver l’assembly dépendant.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()
    

    Notes

    Dans cet exemple, une TypeInitializationException exception a été levée parce qu’un assembly n’a pas pu être chargé.In this example, a TypeInitializationException exception was thrown because an assembly could not be loaded. L’exception peut également être levée si un constructeur statique tente d’ouvrir un fichier de données, tel qu’un fichier de configuration, un fichier XML ou un fichier contenant des données sérialisées, qu’il ne trouve pas.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.

Valeurs de délai d’attente de correspondance d’expression régulièreRegular expression match timeout values

Vous pouvez définir la valeur par défaut du délai d’attente pour une opération de mise en correspondance de modèle d’expression régulière pour chaque domaine d’application.You can set the default timeout value for a regular expression pattern matching operation on a per-application domain basis. Le délai d’attente est défini par un spécifiant une TimeSpan valeur pour la propriété « REGEX_DEFAULT_MATCH_TIMEOUT » à la AppDomain.SetData méthode.The timeout is defined by a specifying a TimeSpan value for the "REGEX_DEFAULT_MATCH_TIMEOUT" property to the AppDomain.SetData method. L’intervalle de temps doit être un TimeSpan objet valide qui est supérieur à zéro et inférieur à environ 24 jours.The time interval must be a valid TimeSpan object that is greater than zero and less than approximately 24 days. Si ces exigences ne sont pas satisfaites, la tentative de définition de la valeur de délai d’attente par défaut lève une ArgumentOutOfRangeException , qui à son tour est encapsulée dans une TypeInitializationException exception.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.

L’exemple suivant montre le TypeInitializationException qui est levé lorsque la valeur assignée à la propriété « REGEX_DEFAULT_MATCH_TIMEOUT » n’est pas valide.The following example shows the TypeInitializationException that is thrown when the value assigned to the "REGEX_DEFAULT_MATCH_TIMEOUT" property is invalid. Pour éliminer l’exception, affectez à la propriété « REGEX_DEFAULT_MATCH_TIMEOUT » une TimeSpan valeur supérieure à zéro et inférieure à environ 24 jours.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()

Calendriers et données culturellesCalendars and cultural data

Si vous tentez d’instancier un calendrier mais que le runtime ne peut pas instancier l' CultureInfo objet qui correspond à ce calendrier, il lève une TypeInitializationException exception.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. Cette exception peut être levée par les constructeurs de classe Calendar suivants :This exception can be thrown by the following calendar class constructors:

Étant donné que les données culturelles de ces cultures doivent être disponibles sur tous les systèmes, vous devez rarement, voire jamais, rencontrer cette exception.Since cultural data for these cultures should be available on all systems, you should rarely, if ever, encounter this exception.

Constructeurs

TypeInitializationException(String, Exception)

Initialise une nouvelle instance de la classe TypeInitializationException avec le message d'erreur par défaut, le nom de type spécifié et une référence à l'exception interne qui est la cause première de cette exception.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.

Propriétés

Data

Obtient une collection de paires clé/valeur qui fournissent des informations définies par l'utilisateur supplémentaires sur l'exception.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Hérité de Exception)
HelpLink

Obtient ou définit un lien vers le fichier d'aide associé à cette exception.Gets or sets a link to the help file associated with this exception.

(Hérité de Exception)
HResult

Obtient ou définit HRESULT, valeur numérique codée qui est assignée à une exception spécifique.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Hérité de Exception)
InnerException

Obtient l'instance Exception qui a provoqué l'exception actuelle.Gets the Exception instance that caused the current exception.

(Hérité de Exception)
Message

Obtient un message qui décrit l'exception active.Gets a message that describes the current exception.

(Hérité de Exception)
Source

Obtient ou définit le nom de l'application ou de l'objet qui est à l'origine de l'erreur.Gets or sets the name of the application or the object that causes the error.

(Hérité de Exception)
StackTrace

Obtient une représentation sous forme de chaîne des frames immédiats sur la pile des appels.Gets a string representation of the immediate frames on the call stack.

(Hérité de Exception)
TargetSite

Obtient la méthode qui lève l'exception actuelle.Gets the method that throws the current exception.

(Hérité de Exception)
TypeName

Obtient le nom qualifié complet du type dont l'initialisation a échoué.Gets the fully qualified name of the type that fails to initialize.

Méthodes

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
GetBaseException()

En cas de substitution dans une classe dérivée, retourne la Exception qui est à l'origine d'une ou de plusieurs exceptions ultérieures.When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions.

(Hérité de Exception)
GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetObjectData(SerializationInfo, StreamingContext)

Définit l'objet SerializationInfo à l'aide du nom de type et d'autres informations se rapportant à l'exception.Sets the SerializationInfo object with the type name and additional exception information.

GetObjectData(SerializationInfo, StreamingContext)

En cas de substitution dans une classe dérivée, définit SerializationInfo avec des informations sur l'exception.When overridden in a derived class, sets the SerializationInfo with information about the exception.

(Hérité de Exception)
GetType()

Obtient le type au moment de l'exécution de l'instance actuelle.Gets the runtime type of the current instance.

(Hérité de Exception)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
ToString()

Crée et retourne une chaîne représentant l'exception actuelle.Creates and returns a string representation of the current exception.

(Hérité de Exception)

Événements

SerializeObjectState

Se produit quand une exception est sérialisée pour créer un objet d'état d'exception qui contient des données sérialisées concernant l'exception.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Hérité de Exception)

S’applique à

Voir aussi