TypeInitializationException Klass

Definition

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

Arv

Object

Exception

TypeInitializationException

Arv

Object

Exception

SystemException

TypeInitializationException

Attribut

SerializableAttribute ComVisibleAttribute

Kommentarer

När en klassinitierare inte kan initiera en typ skapas en TypeInitializationException och skickas en referens till undantaget som genereras av typens klassinitierare. Egenskapen InnerException för TypeInitializationException innehåller det underliggande undantaget.

TypeInitializationException Undantaget återspeglar vanligtvis ett katastrofalt tillstånd (körningen kan inte instansiera en typ) som hindrar ett program från att fortsätta. TypeInitializationException Oftast genereras som svar på vissa ändringar i programmets körmiljö. Därför bör undantaget inte hanteras i ett try/catch block, förutom möjligen för felsökning av felsökningskod. I stället bör orsaken till undantaget undersökas och elimineras.

TypeInitializationException använder HRESULT COR_E_TYPEINITIALIZATION, som har värdet 0x80131534.

För en lista över inledande egenskapsvärden för en instans av TypeInitializationException, se i TypeInitializationException-konstruktorn.

I följande avsnitt beskrivs några av de situationer där ett TypeInitializationException undantag utlöses.

Statiska konstruktorer

Om det finns en statisk konstruktor anropas den automatiskt av körtiden innan en ny instans av en typ skapas. Statiska konstruktorer kan uttryckligen definieras av en utvecklare. Om en statisk konstruktor inte uttryckligen definieras skapar kompilatorer automatiskt en för att initiera alla static (i C# eller F#) eller Shared (i Visual Basic) medlemmar av typen. Mer information om statiska konstruktorer finns i Statiska konstruktorer.

Oftast utlöses ett TypeInitializationException undantag när en statisk konstruktor inte kan instansiera en typ. Egenskapen InnerException anger varför den statiska konstruktorn inte kunde instansiera typen. Några av de vanligaste orsakerna till ett TypeInitializationException undantag är:

• Ett ohanterat undantag i en statisk konstruktor

  Om ett undantag utlöses i en statisk konstruktor omsluts undantaget i ett TypeInitializationException undantag och typen kan inte instansieras.

  Det som ofta gör det här undantaget svårt att felsöka är att statiska konstruktorer inte alltid uttryckligen definieras i källkoden. En statisk konstruktor finns i en typ om:

  • Det har uttryckligen definierats som en medlem av en typ.

  • Typen har static (i C# eller F#) eller Shared (i Visual Basic) variabler som deklareras och initieras i en enda instruktion. I det här fallet genererar språkkompilatorn en statisk konstruktor för typen. När C#- och VB-kompilatorerna kompilerar följande exempel genererar de till exempel IL:en för en statisk konstruktor som liknar detta:

    .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
    

  I följande exempel visas ett TypeInitializationException undantag som genereras av en kompilatorgenererad statisk konstruktor. Klassen Example innehåller ett static (i C#) eller Shared (i Visual Basic)-fält av typen TestClass som instansieras genom att ett värde på 3 skickas till dess klasskonstruktor. Detta värde är dock olagligt. endast värden på 0 eller 1 tillåts. Därför kastar TestClass klasskonstruktorn en ArgumentOutOfRangeException. Eftersom det här undantaget inte hanteras omsluts det av ett TypeInitializationException undantag.

  using System;
  
  public class Example
  {
     private static TestClass test = new TestClass(3);
     
     public static void Main()
     {
        Example ex = new Example();
        Console.WriteLine(test.Value);
     }
  }
  
  public class TestClass
  {
     public readonly int Value;
     
     public TestClass(int value)
     {
        if (value < 0 || value > 1) throw new ArgumentOutOfRangeException(nameof(value));
        Value = value;
     }
  }
  // The example displays the following output:
  //    Unhandled Exception: System.TypeInitializationException: 
  //       The type initializer for 'Example' threw an exception. ---> 
  //       System.ArgumentOutOfRangeException: Specified argument was out of the range of valid values.
  //       at TestClass..ctor(Int32 value)
  //       at Example..cctor()
  //       --- End of inner exception stack trace ---
  //       at Example.Main()
  

  Public Class Example1
      Shared test As New TestClass(3)
  
      Public Shared Sub Main()
          Dim ex As New Example1()
          Console.WriteLine(test.Value)
      End Sub
  End Class
  
  Public Class TestClass
     Public ReadOnly Value As Integer
  
     Public Sub New(value As Integer)
          If value < 0 Or value > 1 Then
              Throw New ArgumentOutOfRangeException(NameOf(value))
          End If
          Value = value
     End Sub
  End Class
  
  ' The example displays the following output:
  '    Unhandled Exception: System.TypeInitializationException:
  '       The type initializer for 'Example' threw an exception. --->
  '       System.ArgumentOutOfRangeException: Specified argument was out of the range of valid values.
  '       at TestClass..ctor(Int32 value)
  '       at Example..cctor()
  '       --- End of inner exception stack trace ---
  '       at Example.Main()
  

  Undantagsmeddelandet visar information om egenskapen InnerException .

• En sammansättning eller datafil som saknas

  En vanlig orsak till ett TypeInitializationException undantag är att en sammansättning eller datafil som fanns i ett programs utvecklings- och testmiljöer saknas i dess körningsmiljö. Du kan till exempel kompilera följande exempel till en sammansättning med namnet Missing1a.dll med hjälp av den här kommandoradssyntaxen:

  csc -t:library Missing1a.cs
  

  fsc --target:library Missing1a.fs
  

  vbc Missing1a.vb -t:library
  

  using System;
  
  public class InfoModule
  {
     private DateTime firstUse;
     private int ctr = 0;
  
     public InfoModule(DateTime dat)
     {
        firstUse = dat;
     }
     
     public int Increment()
     {
        return ++ctr;
     }
     
     public DateTime GetInitializationTime()
     {
        return firstUse;
     }
  }
  

  open System
  
  type InfoModule(firstUse: DateTime) =
      let mutable ctr = 0
  
      member _.Increment() =
          ctr <- ctr + 1
          ctr
     
      member _.GetInitializationTime() =
          firstUse
  

  Public Class InfoModule
     Private firstUse As DateTime
     Private ctr As Integer = 0
  
     Public Sub New(dat As DateTime)
        firstUse = dat
     End Sub
     
     Public Function Increment() As Integer
        ctr += 1
        Return ctr
     End Function
     
     Public Function GetInitializationTime() As DateTime
        Return firstUse
     End Function
  End Class
  

  Du kan sedan kompilera följande exempel till en körbar fil med namnet Missing1.exe genom att inkludera en referens till Missing1a.dll:

  csc Missing1.cs /r:Missing1a.dll
  

  vbc Missing1.vb /r:Missing1a.dll
  

  Men om du byter namn på, flyttar eller tar bort Missing1a.dll och kör exemplet utlöser det ett TypeInitializationException undantag och visar utdata som visas i exemplet. Observera att undantagsmeddelandet innehåller information om egenskapen InnerException . I det här fallet är det inre undantaget ett FileNotFoundException som genereras eftersom körningsmiljön inte kan hitta den beroende sammansättningen.

  using System;
  
  public class MissingEx1
  {
      public static void Main()
      {
          Person p = new Person("John", "Doe");
          Console.WriteLine(p);
      }
  }
  
  public class Person
  {
      static readonly InfoModule s_infoModule;
  
      readonly string _fName;
      readonly string _lName;
  
      static Person()
      {
          s_infoModule = new InfoModule(DateTime.UtcNow);
      }
  
      public Person(string fName, string lName)
      {
          _fName = fName;
          _lName = lName;
          s_infoModule.Increment();
      }
  
      public override string ToString()
      {
          return string.Format("{0} {1}", _fName, _lName);
      }
  }
  // The example displays the following output if missing1a.dll is renamed or removed:
  //    Unhandled Exception: System.TypeInitializationException: 
  //       The type initializer for 'Person' threw an exception. ---> 
  //       System.IO.FileNotFoundException: Could not load file or assembly 
  //       'Missing1a, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null' 
  //       or one of its dependencies. The system cannot find the file specified.
  //       at Person..cctor()
  //       --- End of inner exception stack trace ---
  //       at Person..ctor(String fName, String lName)
  //       at Example.Main()
  

  open System
  
  type Person(fName, lName) =
      static let infoModule = InfoModule DateTime.UtcNow
      
      do infoModule.Increment() |> ignore
     
      override _.ToString() =
          $"{fName} {lName}"
  let p = Person("John", "Doe")
  
  printfn $"{p}"
  // The example displays the following output if missing1a.dll is renamed or removed:
  //    Unhandled Exception: System.TypeInitializationException: 
  //       The type initializer for 'Person' threw an exception. ---> 
  //       System.IO.FileNotFoundException: Could not load file or assembly 
  //       'Missing1a, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null' 
  //       or one of its dependencies. The system cannot find the file specified.
  //       at Person..cctor()
  //       --- End of inner exception stack trace ---
  //       at Person..ctor(String fName, String lName)
  //       at Example.Main()
  

  Module Example3
      Public Sub Main()
          Dim p As New Person("John", "Doe")
          Console.WriteLine(p)
      End Sub
  End Module
  
  Public Class Person
     Shared infoModule As InfoModule
     
     Dim fName As String
     Dim mName As String
     Dim lName As String
     
     Shared Sub New()
        infoModule = New InfoModule(DateTime.UtcNow)
     End Sub
     
     Public Sub New(fName As String, lName As String)
        Me.fName = fName
        Me.lName = lName
        infoModule.Increment()
     End Sub
     
     Public Overrides Function ToString() As String
        Return String.Format("{0} {1}", fName, lName)
     End Function
  End Class
  ' The example displays the following output if missing1a.dll is renamed or removed:
  '    Unhandled Exception: System.TypeInitializationException: 
  '       The type initializer for 'Person' threw an exception. ---> 
  '       System.IO.FileNotFoundException: Could not load file or assembly 
  '       'Missing1a, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null' 
  '       or one of its dependencies. The system cannot find the file specified.
  '       at Person..cctor()
  '       --- End of inner exception stack trace ---
  '       at Person..ctor(String fName, String lName)
  '       at Example.Main()
  

  Note

  I det här exemplet utlöstes ett TypeInitializationException undantag eftersom det inte gick att läsa in en sammansättning. Undantaget kan också utlöses om en statisk konstruktor försöker öppna en datafil, till exempel en konfigurationsfil, en XML-fil eller en fil som innehåller serialiserade data, som den inte kan hitta.

Reguljära uttryck matchar timeout-värden

Du kan ange standardvärdet för timeout för en matchningsåtgärd för reguljära uttrycksmönster per programdomän. Tidsgränsen definieras av en som anger ett TimeSpan värde för egenskapen "REGEX_DEFAULT_MATCH_TIMEOUT" för AppDomain.SetData metoden. Tidsintervallet måste vara ett giltigt TimeSpan objekt som är större än noll och mindre än cirka 24 dagar. Om dessa krav inte uppfylls genererar försöket att ange standardvärdet för timeout ett ArgumentOutOfRangeException, som i sin tur omsluts i ett TypeInitializationException undantag.

I följande exempel visas det TypeInitializationException som genereras när värdet som tilldelats egenskapen "REGEX_DEFAULT_MATCH_TIMEOUT" är ogiltigt. Om du vill eliminera undantaget anger du egenskapen "REGEX_DEFAULT_MATCH_TIMEOUT" till ett TimeSpan värde som är större än noll och mindre än cirka 24 dagar.

using System;
using System.Text.RegularExpressions;
using static System.Net.Mime.MediaTypeNames;

public class RegexEx1
{
    public static void Run()
    {
        AppDomain domain = AppDomain.CurrentDomain;
        // Set a timeout interval of -2 seconds.
        domain.SetData("REGEX_DEFAULT_MATCH_TIMEOUT", TimeSpan.FromSeconds(-2));

        Regex rgx = new Regex("[aeiouy]");
        Console.WriteLine($"Regular expression pattern: {rgx.ToString()}");
        Console.WriteLine($"Timeout interval for this regex: {rgx.MatchTimeout.TotalSeconds} seconds");
    }
}

// The example displays the following output:

//    Unhandled exception. System.TypeInitializationException:
//       The type initializer for 'System.Text.RegularExpressions.Regex' threw an exception. --->
//       System.ArgumentOutOfRangeException: Specified argument was out of the range of valid values.
//       (Parameter 'AppDomain data 'REGEX_DEFAULT_MATCH_TIMEOUT' contains the invalid value or object
//       '-00:00:02' for specifying a default matching timeout for System.Text.RegularExpressions.Regex.')
//       at System.Text.RegularExpressions.Regex.InitDefaultMatchTimeout()
//       at System.Text.RegularExpressions.Regex..cctor()
//       --- End of inner exception stack trace ---
//       at System.Text.RegularExpressions.Regex..ctor(String pattern, CultureInfo culture)
//       at RegexEx1.Run()

open System
open System.Text.RegularExpressions

let domain = AppDomain.CurrentDomain
// Set a timeout interval of -2 seconds.
domain.SetData("REGEX_DEFAULT_MATCH_TIMEOUT", TimeSpan.FromSeconds -2)

let rgx = Regex "[aeiouy]"
printfn $"Regular expression pattern: {rgx}"
printfn $"Timeout interval for this regex: {rgx.MatchTimeout.TotalSeconds} seconds"
// The example displays the following output:
//    Unhandled Exception: System.TypeInitializationException: 
//       The type initializer for 'System.Text.RegularExpressions.Regex' threw an exception. ---> 
//       System.ArgumentOutOfRangeException: Specified argument was out of the range of valid values.
//       Parameter name: AppDomain data 'REGEX_DEFAULT_MATCH_TIMEOUT' contains an invalid value or 
//       object for specifying a default matching timeout for System.Text.RegularExpressions.Regex.
//       at System.Text.RegularExpressions.Regex.InitDefaultMatchTimeout()
//       at System.Text.RegularExpressions.Regex..cctor()
//       --- End of inner exception stack trace ---
//       at System.Text.RegularExpressions.Regex..ctor(String pattern)
//       at Example.Main()

Imports System.Text.RegularExpressions

Module Example4
    Public Sub Main()
        Dim domain As AppDomain = AppDomain.CurrentDomain
        ' Set a timeout interval of -2 seconds.
        domain.SetData("REGEX_DEFAULT_MATCH_TIMEOUT", TimeSpan.FromSeconds(-2))

        Dim rgx As New Regex("[aeiouy]")
        Console.WriteLine("Regular expression pattern: {0}", rgx.ToString())
        Console.WriteLine("Timeout interval for this regex: {0} seconds",
                        rgx.MatchTimeout.TotalSeconds)
    End Sub
End Module
' The example displays the following output:
'    Unhandled Exception: System.TypeInitializationException: 
'       The type initializer for 'System.Text.RegularExpressions.Regex' threw an exception. ---> 
'       System.ArgumentOutOfRangeException: Specified argument was out of the range of valid values.
'       Parameter name: AppDomain data 'REGEX_DEFAULT_MATCH_TIMEOUT' contains an invalid value or 
'       object for specifying a default matching timeout for System.Text.RegularExpressions.Regex.
'       at System.Text.RegularExpressions.Regex.InitDefaultMatchTimeout()
'       at System.Text.RegularExpressions.Regex..cctor()
'       --- End of inner exception stack trace ---
'       at System.Text.RegularExpressions.Regex..ctor(String pattern)
'       at Example.Main()

Kalendrar och kulturella data

Om du försöker instansiera en kalender men körningen inte kan instansiera objektet som motsvarar den CultureInfo kalendern utlöser det ett TypeInitializationException undantag. Det här undantaget kan genereras av följande kalenderklasskonstruktorer:

• Klassens JapaneseCalendar parameterlösa konstruktor.
• Klassens KoreanCalendar parameterlösa konstruktor.
• Klassens TaiwanCalendar parameterlösa konstruktor.

Eftersom kulturella data för dessa kulturer ska vara tillgängliga i alla system bör du sällan, om någonsin, stöta på det här undantaget.

Se även

• Exception
• Hantera och utlösa undantag i .NET