TypeInitializationException Classe

Definição

A exceção gerada como um wrapper em torno da exceção gerada pelo inicializador de classe.The exception that is thrown as a wrapper around the exception thrown by the class initializer. Essa classe não pode ser herdada.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
Herança
TypeInitializationException
Herança
TypeInitializationException
Atributos

Comentários

Quando um inicializador da classe não inicializa um tipo, uma TypeInitializationException é criada e é passada uma referência à exceção gerada pelo inicializador da classe do tipo.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. A InnerException propriedade de TypeInitializationException contém a exceção subjacente.The InnerException property of TypeInitializationException holds the underlying exception.

Normalmente, a TypeInitializationException exceção reflete uma condição catastrófica (o tempo de execução não pode criar uma instância de um tipo) que impede que um aplicativo continue.Typically, the TypeInitializationException exception reflects a catastrophic condition (the runtime is unable to instantiate a type) that prevents an application from continuing. Normalmente, o TypeInitializationException é lançado em resposta a alguma alteração no ambiente de execução do aplicativo.Most commonly, the TypeInitializationException is thrown in response to some change in the executing environment of the application. Consequentemente, além de possivelmente para solucionar problemas de código de depuração, a exceção não deve ser tratada em um try / catch bloco.Consequently, other than possibly for troubleshooting debug code, the exception should not be handled in a try/catch block. Em vez disso, a causa da exceção deve ser investigada e eliminada.Instead, the cause of the exception should be investigated and eliminated.

TypeInitializationException usa o COR_E_TYPEINITIALIZATION HRESULT, que tem o valor 0x80131534.TypeInitializationException uses the HRESULT COR_E_TYPEINITIALIZATION, which has the value 0x80131534.

Para obter uma lista de valores de propriedade inicial para uma instância do TypeInitializationException, consulte o TypeInitializationException construtores.For a list of initial property values for an instance of TypeInitializationException, see the TypeInitializationException constructors.

As seções a seguir descrevem algumas das situações em que uma TypeInitializationException exceção é lançada.The following sections describe some of the situations in which a TypeInitializationException exception is thrown.

Construtores estáticos e TypeInitializationExceptionStatic constructors and the TypeInitializationException

Um construtor estático, se houver, é chamado automaticamente pelo tempo de execução antes de criar uma nova instância de um tipo.A static constructor, if one exists, is called automatically by the runtime before creating a new instance of a type. Construtores estáticos podem ser explicitamente definidos por um desenvolvedor.Static constructors can be explicitly defined by a developer. Se um construtor estático não for definido explicitamente, os compiladores criarão automaticamente um para inicializar qualquer um deles static (em C#) ou Shared (em Visual Basic) membros do tipo.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. Para obter mais informações sobre construtores estáticos, consulte construtores estáticos.For more information on static constructors, see Static Constructors.

Normalmente, uma TypeInitializationException exceção é lançada quando um construtor estático não consegue criar uma instância de um tipo.Most commonly, a TypeInitializationException exception is thrown when a static constructor is unable to instantiate a type. A InnerException propriedade indica por que o construtor estático não pôde criar uma instância do tipo.The InnerException property indicates why the static constructor was unable to instantiate the type. Algumas das causas mais comuns de uma TypeInitializationException exceção são:Some of the more common causes of a TypeInitializationException exception are:

  • Uma exceção sem tratamento em um construtor estáticoAn unhandled exception in a static constructor

    Se uma exceção for lançada em um construtor estático, essa exceção será encapsulada em uma TypeInitializationException exceção e o tipo não poderá ser instanciado.If an exception is thrown in a static constructor, that exception is wrapped in a TypeInitializationException exception, and the type cannot be instantiated.

    O que muitas vezes torna essa exceção difícil de solucionar é que os construtores estáticos nem sempre são definidos explicitamente no código-fonte.What often makes this exception difficult to troubleshoot is that static constructors are not always explicitly defined in source code. Um construtor estático existe em um tipo, se:A static constructor exists in a type if:

    • Ele foi explicitamente definido como um membro de um tipo.It has been explicitly defined as a member of a type.

    • O tipo tem static (em C#) ou Shared (em Visual Basic) variáveis que são declaradas e inicializadas em uma única instrução.The type has static (in C#) or Shared (in Visual Basic) variables that are declared and initialized in a single statement. Nesse caso, o compilador de linguagem gera um construtor estático para o tipo.In this case, the language compiler generates a static constructor for the type. Você pode inspecioná-lo usando um utilitário como o desmontador de Il.You can inspect it by using a utility such as IL Disassembler. Por exemplo, quando os compiladores C# e VB compilam o exemplo a seguir, eles geram o IL para um construtor estático que é semelhante a este: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  
    

    O exemplo a seguir mostra uma TypeInitializationException exceção gerada por um construtor estático gerado pelo compilador.The following example shows a TypeInitializationException exception thrown by a compiler-generated static constructor. A Example classe inclui um static campo (em C#) ou Shared (no Visual Basic) do tipo TestClass que é instanciado passando um valor de 3 para seu construtor 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. No entanto, esse valor é ilegal; somente valores de 0 ou 1 são permitidos.That value, however, is illegal; only values of 0 or 1 are permitted. Como resultado, o TestClass Construtor da classe gera um ArgumentOutOfRangeException .As a result, the TestClass class constructor throws an ArgumentOutOfRangeException. Como essa exceção não é tratada, ela é encapsulada em uma TypeInitializationException exceção.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()
    

    Observe que a mensagem de exceção exibe informações sobre a InnerException propriedade.Note that the exception message displays information about the InnerException property.

  • Um arquivo de assembly ou de dados ausenteA missing assembly or data file

    Uma causa comum de uma TypeInitializationException exceção é que um assembly ou arquivo de dados que estava presente em ambientes de desenvolvimento e teste de um aplicativo está faltando em seu ambiente de tempo de execução.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. Por exemplo, você pode compilar o exemplo a seguir em um assembly chamado Missing1a.dll usando essa sintaxe de linha de comando: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
    

    Em seguida, você pode compilar o exemplo a seguir em um executável chamado Missing1.exe incluindo uma referência a 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  
    

    No entanto, se você renomear, mover ou excluir Missing1a.dll e executar o exemplo, ele lançará uma TypeInitializationException exceção e exibirá a saída mostrada no exemplo.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. Observe que a mensagem de exceção inclui informações sobre a InnerException propriedade.Note that the exception message includes information about the InnerException property. Nesse caso, a exceção interna é uma FileNotFoundException que é gerada porque o tempo de execução não consegue localizar o assembly dependente.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()
    

    Observação

    Neste exemplo, uma TypeInitializationException exceção foi lançada porque um assembly não pôde ser carregado.In this example, a TypeInitializationException exception was thrown because an assembly could not be loaded. A exceção também pode ser gerada se um construtor estático tentar abrir um arquivo de dados, como um arquivo de configuração, um arquivo XML ou um arquivo contendo dados serializados, que ele não pode localizar.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.

Expressão regular corresponde aos valores de tempo limiteRegular expression match timeout values

Você pode definir o valor de tempo limite padrão para uma operação de correspondência de padrão de expressão regular em uma base de domínio por aplicativo.You can set the default timeout value for a regular expression pattern matching operation on a per-application domain basis. O tempo limite é definido por um especificando um TimeSpan valor para a propriedade "REGEX_DEFAULT_MATCH_TIMEOUT" para o AppDomain.SetData método.The timeout is defined by a specifying a TimeSpan value for the "REGEX_DEFAULT_MATCH_TIMEOUT" property to the AppDomain.SetData method. O intervalo de tempo deve ser um TimeSpan objeto válido que seja maior que zero e menor que aproximadamente 24 dias.The time interval must be a valid TimeSpan object that is greater than zero and less than approximately 24 days. Se esses requisitos não forem atendidos, a tentativa de definir o valor de tempo limite padrão lançará um ArgumentOutOfRangeException , que, por sua vez, será encapsulado em uma TypeInitializationException exceção.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.

O exemplo a seguir mostra o TypeInitializationException que é gerado quando o valor atribuído à propriedade "REGEX_DEFAULT_MATCH_TIMEOUT" é inválido.The following example shows the TypeInitializationException that is thrown when the value assigned to the "REGEX_DEFAULT_MATCH_TIMEOUT" property is invalid. Para eliminar a exceção, defina a propriedade "REGEX_DEFAULT_MATCH_TIMEOUT" com um TimeSpan valor maior que zero e menor que aproximadamente 24 dias.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()

Calendários e dados culturaisCalendars and cultural data

Se você tentar criar uma instância de um calendário, mas o tempo de execução não puder criar uma instância do CultureInfo objeto que corresponde a esse calendário, ele lançará uma TypeInitializationException exceção.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. Essa exceção pode ser gerada pelos seguintes construtores de classe de calendário:This exception can be thrown by the following calendar class constructors:

Como os dados culturais para essas culturas devem estar disponíveis em todos os sistemas, você raramente se encontrará essa exceção.Since cultural data for these cultures should be available on all systems, you should rarely, if ever, encounter this exception.

Construtores

TypeInitializationException(String, Exception)

Inicializa uma nova instância da classe TypeInitializationException com a mensagem de erro padrão, o nome de tipo especificado e uma referência à exceção interna que é a causa raiz dessa exceção.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.

Propriedades

Data

Obtém uma coleção de pares de chave/valor que fornecem informações definidas pelo usuário adicionais sobre a exceção.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Herdado de Exception)
HelpLink

Obtém ou define um link para o arquivo de ajuda associado a essa exceção.Gets or sets a link to the help file associated with this exception.

(Herdado de Exception)
HResult

Obtém ou define HRESULT, um valor numérico codificado que é atribuído a uma exceção específica.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Herdado de Exception)
InnerException

Obtém a instância Exception que causou a exceção atual.Gets the Exception instance that caused the current exception.

(Herdado de Exception)
Message

Obtém uma mensagem que descreve a exceção atual.Gets a message that describes the current exception.

(Herdado de Exception)
Source

Obtém ou define o nome do aplicativo ou objeto que causa o erro.Gets or sets the name of the application or the object that causes the error.

(Herdado de Exception)
StackTrace

Obtém uma representação de cadeia de caracteres de quadros imediatos na pilha de chamadas.Gets a string representation of the immediate frames on the call stack.

(Herdado de Exception)
TargetSite

Obtém o método que gerou a exceção atual.Gets the method that throws the current exception.

(Herdado de Exception)
TypeName

Obtém o nome totalmente qualificado do tipo cuja inicialização falha.Gets the fully qualified name of the type that fails to initialize.

Métodos

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(Herdado de Object)
GetBaseException()

Quando substituído em uma classe derivada, retorna a Exception que é a causa raiz de uma ou mais exceções subsequentes.When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions.

(Herdado de Exception)
GetHashCode()

Serve como a função de hash padrão.Serves as the default hash function.

(Herdado de Object)
GetObjectData(SerializationInfo, StreamingContext)

Define o objeto SerializationInfo com o nome de tipo e informações adicionais de exceção.Sets the SerializationInfo object with the type name and additional exception information.

GetObjectData(SerializationInfo, StreamingContext)

Quando substituído em uma classe derivada, define o SerializationInfo com informações sobre a exceção.When overridden in a derived class, sets the SerializationInfo with information about the exception.

(Herdado de Exception)
GetType()

Obtém o tipo de runtime da instância atual.Gets the runtime type of the current instance.

(Herdado de Exception)
MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Herdado de Object)
ToString()

Cria e retorna uma representação de cadeia de caracteres da exceção atual.Creates and returns a string representation of the current exception.

(Herdado de Exception)

Eventos

SerializeObjectState

Ocorre quando uma exceção é serializada para criar um objeto de estado de exceção que contém dados serializados sobre a exceção.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Herdado de Exception)

Aplica-se a

Veja também