BadImageFormatException Klasse

Definition

Die Ausnahme, die ausgelöst wird, wenn das Dateiimage einer Dynamic Link Library (DLL) oder eines ausführbaren Programms ungültig ist.

public ref class BadImageFormatException : Exception
public ref class BadImageFormatException : SystemException
public class BadImageFormatException : Exception
public class BadImageFormatException : SystemException
[System.Serializable]
public class BadImageFormatException : SystemException
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class BadImageFormatException : SystemException
type BadImageFormatException = class
    inherit Exception
type BadImageFormatException = class
    inherit SystemException
[<System.Serializable>]
type BadImageFormatException = class
    inherit SystemException
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type BadImageFormatException = class
    inherit SystemException
Public Class BadImageFormatException
Inherits Exception
Public Class BadImageFormatException
Inherits SystemException
Vererbung
BadImageFormatException
Vererbung
BadImageFormatException
Attribute

Hinweise

Diese Ausnahme wird ausgelöst, wenn das Dateiformat einer Dynamic Link Library (.dll-Datei) oder einer ausführbaren Datei (.exe-Datei) nicht dem Von der Common Language Runtime erwarteten Format entspricht. Insbesondere wird die Ausnahme unter den folgenden Bedingungen ausgelöst:

  • Eine frühere Version eines .NET-Hilfsprogramms, z. B. ILDasm.exe oder installutil.exe, wird mit einer Assembly verwendet, die mit einer späteren Version von .NET entwickelt wurde.

    Um diese Ausnahme zu beheben, verwenden Sie die Version des Tools, die der Version von .NET entspricht, die zum Entwickeln der Assembly verwendet wurde. Dies kann das Ändern der Path Umgebungsvariablen oder das Bereitstellen eines vollqualifizierten Pfads zur richtigen ausführbaren Datei erfordern.

  • Sie versuchen, eine nicht verwaltete Dynamic Link Library oder ausführbare Datei (z. B. eine Windows System-DLL) zu laden, als wäre es eine .NET-Assembly. Im folgenden Beispiel wird dies mithilfe der Assembly.LoadFile -Methode veranschaulicht, um Kernel32.dll zu laden.

    // Windows DLL (non-.NET assembly)
    string filePath = Environment.ExpandEnvironmentVariables("%windir%");
    if (! filePath.Trim().EndsWith(@"\"))
       filePath += @"\";
    filePath += @"System32\Kernel32.dll";
    
    try {
       Assembly assem = Assembly.LoadFile(filePath);
    }
    catch (BadImageFormatException e) {
       Console.WriteLine("Unable to load {0}.", filePath);
       Console.WriteLine(e.Message.Substring(0,
                         e.Message.IndexOf(".") + 1));
    }
    // The example displays an error message like the following:
    //       Unable to load C:\WINDOWS\System32\Kernel32.dll.
    //       The module was expected to contain an assembly manifest.
    
    ' Windows DLL (non-.NET assembly)
    Dim filePath As String = Environment.ExpandEnvironmentVariables("%windir%")
    If Not filePath.Trim().EndsWith("\") Then filepath += "\"
    filePath += "System32\Kernel32.dll"
    Try
       Dim assem As Assembly = Assembly.LoadFile(filePath)
    Catch e As BadImageFormatException
       Console.WriteLine("Unable to load {0}.", filePath)
       Console.WriteLine(e.Message.Substring(0, _
                         e.Message.IndexOf(".") + 1))   
    End Try
    ' The example displays an error message like the following:
    '       Unable to load C:\WINDOWS\System32\Kernel32.dll.
    '       The module was expected to contain an assembly manifest.
    

    Um diese Ausnahme zu beheben, greifen Sie auf die in der DLL definierten Methoden zu, indem Sie die von Ihrer Entwicklungssprache bereitgestellten Funktionen verwenden, z. B. die Declare -Anweisung in Visual Basic oder das DllImportAttribute -Attribut mit dem extern Schlüsselwort in C#.

  • Sie versuchen, eine Verweisassembly in einem anderen Kontext als dem reflektionsbezogenen Kontext zu laden. Sie können dieses Problem auf zwei Arten beheben:

    • Sie können die Implementierungsassembly anstelle der Verweisassembly laden.
    • Sie können die Verweisassembly im Reflektionskontext laden, indem Sie die Assembly.ReflectionOnlyLoad -Methode aufrufen.
  • Eine DLL oder ausführbare Datei wird als 64-Bit-Assembly geladen, enthält jedoch 32-Bit-Features oder -Ressourcen. Beispielsweise basiert sie auf COM-Interop oder ruft Methoden in einer 32-Bit-Bibliothek für dynamische Links auf.

    Um diese Ausnahme zu beheben, legen Sie die Platform-Zieleigenschaft des Projekts auf x86 (anstelle von x64 oder AnyCPU) fest, und kompilieren Sie erneut.

  • Die Komponenten Ihrer Anwendung wurden mit verschiedenen Versionen von .NET erstellt. Diese Ausnahme tritt in der Regel auf, wenn eine Anwendung oder Komponente, die mit dem .NET Framework 1.0 oder .NET Framework 1.1 entwickelt wurde, versucht, eine Assembly zu laden, die mit dem .NET Framework 2.0 SP1 oder höher entwickelt wurde, oder wenn eine Anwendung, die mit dem .NET Framework 2.0 SP1 oder .NET Framework 3.5 entwickelt wurde, versucht, eine Assembly zu laden, die mit dem .NET Framework 4 oder höher entwickelt wurde. Kann BadImageFormatException als Kompilierzeitfehler gemeldet werden, oder die Ausnahme kann zur Laufzeit ausgelöst werden. Im folgenden Beispiel wird eine StringLib Klasse definiert, die über einen einzelnen Member , ToProperCase und verfügt, der sich in einer Assembly namens StringLib.dll befindet.

    using System;
    
    public class StringLib
    {
       private string[] exceptionList = { "a", "an", "the", "in", "on", "of" };
       private char[] separators = { ' ' };
    
       public string ToProperCase(string title)
       {
          bool isException = false;	
    
          string[] words = title.Split( separators, StringSplitOptions.RemoveEmptyEntries);
          string[] newWords = new string[words.Length];
            
          for (int ctr = 0; ctr <= words.Length - 1; ctr++)
          {
             isException = false;
    
             foreach (string exception in exceptionList)
             {
                if (words[ctr].Equals(exception) && ctr > 0)
                {
                   isException = true;
                   break;
                }
             }
    
             if (! isException)
                newWords[ctr] = words[ctr].Substring(0, 1).ToUpper() + words[ctr].Substring(1);
             else
                newWords[ctr] = words[ctr];	
          }	
          return string.Join(" ", newWords); 			
       }
    }
    // Attempting to load the StringLib.dll assembly produces the following output:
    //    Unhandled Exception: System.BadImageFormatException:
    //                         The format of the file 'StringLib.dll' is invalid.
    
    Public Module StringLib
       Private exceptionList() As String = { "a", "an", "the", "in", "on", "of" }
       Private separators() As Char = { " "c }
       
       Public Function ToProperCase(title As String) As String
          Dim isException As Boolean = False	
          
          Dim words() As String = title.Split( separators, StringSplitOptions.RemoveEmptyEntries)
          Dim newWords(words.Length) As String
            
          For ctr As Integer = 0 To words.Length - 1
             isException = False
    
             For Each exception As String In exceptionList
                If words(ctr).Equals(exception) And ctr > 0 Then
                   isException = True
                   Exit For
                End If
             Next
             If Not isException Then
                newWords(ctr) = words(ctr).Substring(0, 1).ToUpper() + words(ctr).Substring(1)
             Else
                newWords(ctr) = words(ctr)	 
             End If	 
          Next	
          Return String.Join(" ", newWords) 			
       End Function
    End Module
    

    Im folgenden Beispiel wird Reflektion verwendet, um eine Assembly mit dem Namen StringLib.dll zu laden. Wenn der Quellcode mit einem .NET Framework 1.1-Compiler kompiliert BadImageFormatException wird, wird von der Assembly.LoadFrom -Methode ausgelöst.

    using System;
    using System.Reflection;
    
    public class Example
    {
       public static void Main()
       {
          string title = "a tale of two cities";
    //      object[] args = { title}
          // Load assembly containing StateInfo type.
          Assembly assem = Assembly.LoadFrom(@".\StringLib.dll");
          // Get type representing StateInfo class.
          Type stateInfoType = assem.GetType("StringLib");
          // Get Display method.
          MethodInfo mi = stateInfoType.GetMethod("ToProperCase");
          // Call the Display method.
          string properTitle = (string) mi.Invoke(null, new object[] { title } );
          Console.WriteLine(properTitle);
       }
    }
    
    Imports System.Reflection
    
    Module Example
       Public Sub Main()
          Dim title As String = "a tale of two cities"
          ' Load assembly containing StateInfo type.
          Dim assem As Assembly = Assembly.LoadFrom(".\StringLib.dll")
          ' Get type representing StateInfo class.
          Dim stateInfoType As Type = assem.GetType("StringLib")
          ' Get Display method.
          Dim mi As MethodInfo = stateInfoType.GetMethod("ToProperCase")
          ' Call the Display method. 
          Dim properTitle As String = CStr(mi.Invoke(Nothing, New Object() { title } ))
          Console.WriteLine(properTitle)
       End Sub
    End Module
    ' Attempting to load the StringLib.dll assembly produces the following output:
    '    Unhandled Exception: System.BadImageFormatException: 
    '                         The format of the file 'StringLib.dll' is invalid.
    

    Um diese Ausnahme zu beheben, stellen Sie sicher, dass die Assembly, deren Code ausgeführt wird und die Ausnahme auslöst, und die assembly, die geladen werden soll, beide kompatible Versionen von .NET als Ziel verwenden.

  • Die Komponenten Ihrer Anwendung sind auf verschiedene Plattformen ausgerichtet. Sie versuchen beispielsweise, ARM-Assemblys in einer x86-Anwendung zu laden. Sie können das folgende Befehlszeilenprogramm verwenden, um die Zielplattformen einzelner .NET-Assemblys zu bestimmen. Die Liste der Dateien sollte als durch Leerzeichen getrennte Liste in der Befehlszeile bereitgestellt werden.

    using System;
    using System.IO;
    using System.Reflection;
    
    public class Example
    {
       public static void Main()
       {
          String[] args = Environment.GetCommandLineArgs();
          if (args.Length == 1) {
             Console.WriteLine("\nSyntax:   PlatformInfo <filename>\n");
             return;
          }
          Console.WriteLine();
    
          // Loop through files and display information about their platform.
          for (int ctr = 1; ctr < args.Length; ctr++) {
             string fn = args[ctr];
             if (! File.Exists(fn)) {
                Console.WriteLine("File: {0}", fn);
                Console.WriteLine("The file does not exist.\n");
             }
             else {
                try {
                   AssemblyName an = AssemblyName.GetAssemblyName(fn);
                   Console.WriteLine("Assembly: {0}", an.Name);
                   if (an.ProcessorArchitecture == ProcessorArchitecture.MSIL)
                      Console.WriteLine("Architecture: AnyCPU");
                   else
                      Console.WriteLine("Architecture: {0}", an.ProcessorArchitecture);
    
                   Console.WriteLine();
                }
                catch (BadImageFormatException) {
                   Console.WriteLine("File: {0}", fn);
                   Console.WriteLine("Not a valid assembly.\n");
                }
             }
          }
       }
    }
    
    Imports System.IO
    Imports System.Reflection
    
    Module Example
       Public Sub Main()
          Dim args() As String = Environment.GetCommandLineArgs()
          If args.Length = 1 Then
             Console.WriteLine()
             Console.WriteLine("Syntax:   PlatformInfo <filename> ")
             Console.WriteLine()
             Exit Sub
          End If
          Console.WriteLine()
          
          ' Loop through files and display information about their platform.
          For ctr As Integer = 1 To args.Length - 1
             Dim fn As String = args(ctr)
             If Not File.Exists(fn) Then
                Console.WriteLine("File: {0}", fn)
                Console.WriteLine("The file does not exist.")
                Console.WriteLine()
             Else
                Try
                   Dim an As AssemblyName = AssemblyName.GetAssemblyName(fn)
                   Console.WriteLine("Assembly: {0}", an.Name)
                   If an.ProcessorArchitecture = ProcessorArchitecture.MSIL Then
                      Console.WriteLine("Architecture: AnyCPU")
                   Else
                      Console.WriteLine("Architecture: {0}", an.ProcessorArchitecture)
                   End If
                Catch e As BadImageFormatException
                   Console.WriteLine("File: {0}", fn)
                   Console.WriteLine("Not a valid assembly.\n")
                End Try
                Console.WriteLine()
             End If
          Next
       End Sub
    End Module
    
  • Diese Ausnahme kann durch Reflektion auf ausführbare Dateien in C++ ausgelöst werden. Meistens hat dabei der C++-Compiler die Umsetzungsadressen oder den .Reloc-Abschnitt der ausführbaren Datei entfernt. Damit die Umsetzungsadresse in einer ausführbaren Datei in C++ erhalten bleibt, geben Sie beim Verknüpfen /fixed:no an.

BadImageFormatException verwendet das HRESULT COR_E_BADIMAGEFORMAT , das den Wert 0x8007000B hat.

Eine Liste der anfänglichen Eigenschaftswerte für eine Instanz von BadImageFormatException, finden Sie unter den BadImageFormatException Konstruktoren.

Konstruktoren

BadImageFormatException()

Initialisiert eine neue Instanz der BadImageFormatException-Klasse.

BadImageFormatException(SerializationInfo, StreamingContext)

Initialisiert eine neue Instanz der BadImageFormatException-Klasse mit serialisierten Daten.

BadImageFormatException(String)

Initialisiert eine neue Instanz der BadImageFormatException-Klasse mit einer angegebenen Fehlermeldung.

BadImageFormatException(String, Exception)

Initialisiert eine neue Instanz der BadImageFormatException-Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat.

BadImageFormatException(String, String)

Initialisiert eine neue Instanz der BadImageFormatException-Klasse mit einer angegebenen Fehlermeldung und einem angegebenen Dateinamen.

BadImageFormatException(String, String, Exception)

Initialisiert eine neue Instanz der BadImageFormatException-Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat.

Eigenschaften

Data

Ruft eine Auflistung von Schlüssel-Wert-Paaren ab, die zusätzliche benutzerdefinierte Informationen zur Ausnahme bereitstellen.

(Geerbt von Exception)
FileName

Ruft den Namen der Datei ab, die diese Ausnahme verursacht hat.

FusionLog

Ruft die Protokolldatei ab, in der beschrieben wird, warum das Laden einer Assembly fehlschlug.

HelpLink

Ruft einen Link zur Hilfedatei ab, die dieser Ausnahme zugeordnet ist, oder legt einen Link fest.

(Geerbt von Exception)
HResult

Ruft HRESULT ab oder legt HRESULT fest. Dies ist ein codierter Wert, der einer bestimmten Ausnahme zugeordnet ist.

(Geerbt von Exception)
InnerException

Ruft die Exception-Instanz ab, die die aktuelle Ausnahme verursacht hat.

(Geerbt von Exception)
Message

Ruft die Fehlermeldung und den Namen der Datei ab, die diese Ausnahme verursacht hat.

Source

Gibt den Namen der Anwendung oder des Objekts zurück, die bzw. das den Fehler verursacht hat, oder legt diesen fest.

(Geerbt von Exception)
StackTrace

Ruft eine Zeichenfolgendarstellung der unmittelbaren Frames in der Aufrufliste ab.

(Geerbt von Exception)
TargetSite

Ruft die Methode ab, die die aktuelle Ausnahme auslöst.

(Geerbt von Exception)

Methoden

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
GetBaseException()

Gibt beim Überschreiben in einer abgeleiteten Klasse eine Exception zurück, die die Grundursache für eine oder mehrere nachfolgende Ausnahmen ist.

(Geerbt von Exception)
GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetObjectData(SerializationInfo, StreamingContext)

Legt das SerializationInfo-Objekt mit dem Dateinamen, dem Assemblycache-Protokoll und zusätzlichen Informationen zur Ausnahme fest.

GetObjectData(SerializationInfo, StreamingContext)

Legt beim Überschreiben in einer abgeleiteten Klasse die SerializationInfo mit Informationen über die Ausnahme fest.

(Geerbt von Exception)
GetType()

Ruft den Laufzeittyp der aktuellen Instanz ab.

(Geerbt von Exception)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
ToString()

Gibt den vollqualifizierten Namen dieser Ausnahme und ggf. die Fehlermeldung sowie den Namen der inneren Ausnahme und die Stapelüberwachung zurück.

Ereignisse

SerializeObjectState
Veraltet.

Tritt auf, wenn eine Ausnahme serialisiert wird, um ein Ausnahmezustandsobjekt mit serialisierten Daten über die Ausnahme zu erstellen.

(Geerbt von Exception)

Gilt für

Siehe auch