TypeInitializationException TypeInitializationException TypeInitializationException TypeInitializationException Class

Definizione

Eccezione generata come wrapper per l'eccezione generata dall'inizializzatore di classi.The exception that is thrown as a wrapper around the exception thrown by the class initializer. Questa classe non può essere ereditata.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
Ereditarietà
TypeInitializationExceptionTypeInitializationExceptionTypeInitializationExceptionTypeInitializationException
Attributi

Commenti

Quando un inizializzatore di classi non inizializza un tipo, viene creata un'eccezione TypeInitializationException che viene passata come riferimento all'eccezione generata dall'inizializzatore di classi del 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. La InnerException proprietà di TypeInitializationException include l'eccezione sottostante.The InnerException property of TypeInitializationException holds the underlying exception.

In genere, TypeInitializationException l'eccezione riflette una condizione irreversibile (il runtime non è in grado di creare un'istanza di un tipo) che impedisce a un'applicazione di continuare.Typically, the TypeInitializationException exception reflects a catastrophic condition (the runtime is unable to instantiate a type) that prevents an application from continuing. In genere, TypeInitializationException viene generata un'eccezione in risposta a una modifica nell'ambiente in esecuzione dell'applicazione.Most commonly, the TypeInitializationException is thrown in response to some change in the executing environment of the application. Di conseguenza, a parte la risoluzione dei problemi del codice di debug, l'eccezione non deve essere try gestita in un / catch blocco.Consequently, other than possibly for troubleshooting debug code, the exception should not be handled in a try/catch block. Al contrario, la ragione dell'eccezione deve essere analizzata ed eliminata.Instead, the cause of the exception should be investigated and eliminated.

TypeInitializationExceptionUSA HRESULT COR_E_TYPEINITIALIZATION, che ha il valore 0x80131534.TypeInitializationException uses the HRESULT COR_E_TYPEINITIALIZATION, which has the value 0x80131534.

Per un elenco di valori di proprietà iniziali per un'istanza di TypeInitializationException, vedere il TypeInitializationException costruttori.For a list of initial property values for an instance of TypeInitializationException, see the TypeInitializationException constructors.

Nelle sezioni seguenti vengono descritte alcune situazioni in cui viene generata TypeInitializationException un'eccezione.The following sections describe some of the situations in which a TypeInitializationException exception is thrown.

Costruttori statici e TypeInitializationExceptionStatic constructors and the TypeInitializationException

Un costruttore statico, se esistente, viene chiamato automaticamente dal runtime prima di creare una nuova istanza di un tipo.A static constructor, if one exists, is called automatically by the runtime before creating a new instance of a type. I costruttori statici possono essere definiti in modo esplicito da uno sviluppatore.Static constructors can be explicitly defined by a developer. Se un costruttore statico non è definito in modo esplicito, i compilatori ne creano static automaticamente uno C#per inizializzare i membri (in) o Shared (in Visual Basic) del 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. Per ulteriori informazioni sui costruttori statici, vedere costruttori statici.For more information on static constructors, see Static Constructors.

In genere, un' TypeInitializationException eccezione viene generata quando un costruttore statico non è in grado di creare un'istanza di un tipo.Most commonly, a TypeInitializationException exception is thrown when a static constructor is unable to instantiate a type. La InnerException proprietà indica perché il costruttore statico non è stato in grado di creare un'istanza del tipo.The InnerException property indicates why the static constructor was unable to instantiate the type. Di seguito sono riportate alcune delle TypeInitializationException cause più comuni di un'eccezione:Some of the more common causes of a TypeInitializationException exception are:

  • Un'eccezione non gestita in un costruttore staticoAn unhandled exception in a static constructor

    Se un'eccezione viene generata in un costruttore statico, tale eccezione viene racchiusa in TypeInitializationException un'eccezione e non è possibile creare un'istanza del tipo.If an exception is thrown in a static constructor, that exception is wrapped in a TypeInitializationException exception, and the type cannot be instantiated.

    Ciò che spesso rende difficoltosa la risoluzione di questa eccezione è che i costruttori statici non sono sempre definiti in modo esplicito nel codice sorgente.What often makes this exception difficult to troubleshoot is that static constructors are not always explicitly defined in source code. Un costruttore statico esiste in un tipo se:A static constructor exists in a type if:

    • È stato definito in modo esplicito come membro di un tipo.It has been explicitly defined as a member of a type.

    • Il tipo include static le variabili C#(in Shared ) o (in Visual Basic) dichiarate e inizializzate in una singola istruzione.The type has static (in C#) or Shared (in Visual Basic) variables that are declared and initialized in a single statement. In questo caso, il compilatore di linguaggio genera un costruttore statico per il tipo.In this case, the language compiler generates a static constructor for the type. È possibile esaminarlo usando un'utilità, ad esempio il disassembler il.You can inspect it by using a utility such as IL Disassembler. Ad esempio, quando i C# compilatori e VB compilano l'esempio seguente, generano il linguaggio il per un costruttore statico simile al seguente: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  
    

    Nell'esempio seguente viene illustrata un' TypeInitializationException eccezione generata da un costruttore statico generato dal compilatore.The following example shows a TypeInitializationException exception thrown by a compiler-generated static constructor. La Example classe include un static campo ( C#in) Shared o (in Visual Basic) di tipo TestClass di cui viene creata un'istanza passando un valore di 3 al relativo costruttore di 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. Tale valore, tuttavia, non è valido; sono consentiti solo i valori 0 o 1.That value, however, is illegal; only values of 0 or 1 are permitted. Di conseguenza, il costruttore TestClass della classe genera un' ArgumentOutOfRangeExceptioneccezione.As a result, the TestClass class constructor throws an ArgumentOutOfRangeException. Poiché questa eccezione non viene gestita, viene racchiusa in un' TypeInitializationException eccezione.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()
    

    Si noti che nel messaggio di eccezione vengono visualizzate InnerException informazioni sulla proprietà.Note that the exception message displays information about the InnerException property.

  • Un file di dati o di assembly mancanteA missing assembly or data file

    Una provocazione comune di TypeInitializationException un'eccezione è rappresentata dal fatto che un assembly o un file di dati presente negli ambienti di sviluppo e test di un'applicazione non è presente nell'ambiente di Runtime.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. È ad esempio possibile compilare l'esempio seguente in un assembly denominato Missing1a. dll utilizzando questa sintassi della riga di 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
    

    È quindi possibile compilare l'esempio seguente in un eseguibile denominato Missing1. exe includendo un riferimento 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  
    

    Tuttavia, se si rinomina, sposta o Elimina Missing1a. dll e si esegue l'esempio, viene generata un' TypeInitializationException eccezione e viene visualizzato l'output visualizzato nell'esempio.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. Si noti che il messaggio di eccezione include informazioni InnerException sulla proprietà.Note that the exception message includes information about the InnerException property. In questo caso, l'eccezione interna è un' FileNotFoundException eccezione generata perché il runtime non è in grado di trovare l'assembly dipendente.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()
    

    Nota

    In questo esempio è stata TypeInitializationException generata un'eccezione perché non è stato possibile caricare un assembly.In this example, a TypeInitializationException exception was thrown because an assembly could not be loaded. L'eccezione può essere generata anche se un costruttore statico tenta di aprire un file di dati, ad esempio un file di configurazione, un file XML o un file contenente dati serializzati, che non è in grado di trovare.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.

Valori di timeout delle corrispondenze di espressione regolareRegular expression match timeout values

È possibile impostare il valore di timeout predefinito per un'operazione di criteri di ricerca di espressioni regolari in base al dominio dell'applicazione.You can set the default timeout value for a regular expression pattern matching operation on a per-application domain basis. Il timeout è definito da un oggetto TimeSpan AppDomain.SetData che specifica un valore per la proprietà "REGEX_DEFAULT_MATCH_TIMEOUT" al metodo.The timeout is defined by a specifying a TimeSpan value for the "REGEX_DEFAULT_MATCH_TIMEOUT" property to the AppDomain.SetData method. L'intervallo di tempo deve essere un TimeSpan oggetto valido maggiore di zero e minore di circa 24 giorni.The time interval must be a valid TimeSpan object that is greater than zero and less than approximately 24 days. Se questi requisiti non vengono soddisfatti, il tentativo di impostare il valore di timeout predefinito genera ArgumentOutOfRangeExceptionun'eccezione, che a sua volta viene TypeInitializationException sottoposta a incapsulamento in un'eccezione.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.

Nell'esempio seguente viene illustrato TypeInitializationException l'eccezione generata quando il valore assegnato alla proprietà "REGEX_DEFAULT_MATCH_TIMEOUT" non è valido.The following example shows the TypeInitializationException that is thrown when the value assigned to the "REGEX_DEFAULT_MATCH_TIMEOUT" property is invalid. Per eliminare l'eccezione, impostare la proprietà "REGEX_DEFAULT_MATCH_TIMEOUT" su un TimeSpan valore maggiore di zero e minore di circa 24 giorni.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()

Calendari e dati culturaliCalendars and cultural data

Se si tenta di creare un'istanza di un calendario, ma il runtime non è in CultureInfo grado di creare un'istanza dell'oggetto che corrisponde al TypeInitializationException calendario, viene generata un'eccezione.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. Questa eccezione può essere generata dai costruttori della classe Calendar seguenti:This exception can be thrown by the following calendar class constructors:

Poiché i dati culturali per queste impostazioni cultura devono essere disponibili in tutti i sistemi, è necessario raramente, se non mai, si verifica questa eccezione.Since cultural data for these cultures should be available on all systems, you should rarely, if ever, encounter this exception.

Costruttori

TypeInitializationException(String, Exception) TypeInitializationException(String, Exception) TypeInitializationException(String, Exception) TypeInitializationException(String, Exception)

Consente di inizializzare una nuova istanza della classe TypeInitializationException con il messaggio di errore predefinito, il nome del tipo specificato e un riferimento all'eccezione interna che è la causa radice dell'eccezione corrente.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.

Proprietà

Data Data Data Data

Ottiene una raccolta di coppie chiave-valore che fornisce informazioni aggiuntive definite dall'utente relative all'eccezione.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Inherited from Exception)
HelpLink HelpLink HelpLink HelpLink

Ottiene o imposta un collegamento al file della Guida associato all'eccezione.Gets or sets a link to the help file associated with this exception.

(Inherited from Exception)
HResult HResult HResult HResult

Ottiene o imposta HRESULT, un valore numerico codificato che viene assegnato a un'eccezione specifica.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Inherited from Exception)
InnerException InnerException InnerException InnerException

Ottiene l'istanza di Exception che ha causato l'eccezione corrente.Gets the Exception instance that caused the current exception.

(Inherited from Exception)
Message Message Message Message

Ottiene un messaggio che descrive l'eccezione corrente.Gets a message that describes the current exception.

(Inherited from Exception)
Source Source Source Source

Ottiene o imposta il nome dell'oggetto o dell'applicazione che ha generato l'errore.Gets or sets the name of the application or the object that causes the error.

(Inherited from Exception)
StackTrace StackTrace StackTrace StackTrace

Ottiene una rappresentazione di stringa dei frame immediati nello stack di chiamate.Gets a string representation of the immediate frames on the call stack.

(Inherited from Exception)
TargetSite TargetSite TargetSite TargetSite

Ottiene il metodo che genera l'eccezione corrente.Gets the method that throws the current exception.

(Inherited from Exception)
TypeName TypeName TypeName TypeName

Ottiene il nome completo del tipo che non riesce ad eseguire l'inizializzazione.Gets the fully qualified name of the type that fails to initialize.

Metodi

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetBaseException() GetBaseException() GetBaseException() GetBaseException()

Se utilizzato come metodo di override in una classe derivata, restituisce l'Exception che è la causa radice di una o più eccezioni successive.When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions.

(Inherited from Exception)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Inherited from Object)
GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext)

Imposta l'oggetto SerializationInfo con il nome del tipo e informazioni aggiuntive sull'eccezione.Sets the SerializationInfo object with the type name and additional exception information.

GetType() GetType() GetType() GetType()

Ottiene il tipo di runtime dell'istanza corrente.Gets the runtime type of the current instance.

(Inherited from Exception)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Crea e restituisce una rappresentazione di stringa dell'eccezione corrente.Creates and returns a string representation of the current exception.

(Inherited from Exception)

Eventi

SerializeObjectState SerializeObjectState SerializeObjectState SerializeObjectState

Si verifica quando un'eccezione viene serializzata per creare un oggetto di stato eccezione contenente i dati serializzati relativi all'eccezione.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Inherited from Exception)

Si applica a

Vedi anche