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 dynamischen Linkbibliothek (.dll Datei) oder einer ausführbaren Datei (.exe Datei) nicht dem Format entspricht, das die allgemeine Sprachlaufzeit erwartet. Insbesondere wird die Ausnahme unter den folgenden Bedingungen ausgelöst:

  • Eine frühere Version eines .NET-Dienstprogramms, 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, das der Version von .NET entspricht, die zum Entwickeln der Assembly verwendet wurde. Dies erfordert möglicherweise das Ändern der Path Umgebungsvariable oder das Bereitstellen eines vollqualifizierten Pfads zur richtigen ausführbaren Datei.

  • Sie versuchen, eine nicht verwaltete Dynamic Link Library oder ausführbare Datei (z. B. eine Windows System-DLL) zu laden, als ob es sich um eine .NET-Assembly handelt. 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.
    
    open System
    open System.Reflection
    
    // Windows DLL (non-.NET assembly)
    let filePath = 
        let filePath = Environment.ExpandEnvironmentVariables "%windir%"
        let filePath =
            if not (filePath.Trim().EndsWith @"\") then
                filePath + @"\"
            else filePath
        filePath + @"System32\Kernel32.dll"
    
    try
        Assembly.LoadFile filePath |> ignore
    with :? BadImageFormatException as e ->
       printfn $"Unable to load {filePath}."
       printfn $"{e.Message[0 .. e.Message.IndexOf '.']}"
    
    // The example displays an error message like the following:
    //       Unable to load C:\WINDOWS\System32\Kernel32.dll.
    //       Bad IL format.
    
    ' 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 methoden zu, die in der DLL definiert sind, indem Sie die Von Ihrer Entwicklungssprache bereitgestellten Features verwenden, z. B. die Declare Anweisung in Visual Basic oder das DllImportAttribute Attribut mit dem extern Schlüsselwort in C# und F#.

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

    • Sie können die Implementierungsassembly anstelle der Referenzassembly laden.
    • Sie können die Referenzassembly im Nur-Spiegelungskontext 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. Sie basiert beispielsweise auf COM-Interop- oder Aufrufmethoden in einer 32-Bit-Bibliothek für dynamische Verknüpfungen.

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

  • Die Komponenten Ihrer Anwendung wurden mithilfe verschiedener Versionen von .NET erstellt. In der Regel tritt diese Ausnahme auf, wenn eine Anwendung oder Komponente, die mithilfe der .NET Framework 1.0 oder der .NET Framework 1.1 entwickelt wurde, versucht, eine Assembly zu laden, die mithilfe der .NET Framework 2.0 SP1 oder höher entwickelt wurde, oder wenn eine Anwendung, die mit dem .NET Framework 2.0 SP1 entwickelt wurde, oder wenn eine Anwendung, die mit dem .NET Framework 2.0 SP1 entwickelt wurde, oder .NET Framework 3.5 versucht, eine Assembly zu laden, die mithilfe der .NET Framework 4 oder höher entwickelt wurde. Der BadImageFormatException Fehler kann als Kompilierungszeitfehler gemeldet werden, oder die Ausnahme kann zur Laufzeit ausgelöst werden. Im folgenden Beispiel wird eine StringLib Klasse definiert, ToProperCasedie über ein einzelnes Element verfügt und sich in einer Assembly mit dem Namen 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.
    
    open System
    
    module StringLib =
        let private exceptionList = [ "a"; "an"; "the"; "in"; "on"; "of" ]
        let private separators = [| ' ' |]
    
        [<CompiledName "ToProperCase">]
        let toProperCase (title: string) =
            title.Split(separators, StringSplitOptions.RemoveEmptyEntries)
            |> Array.mapi (fun i word ->
                if i <> 0 && List.contains word exceptionList then
                    word
                else 
                    word[0..0].ToUpper() + word[1..])
            |> String.concat " "
    
    // 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 die Spiegelung verwendet, um eine Assembly mit dem Namen StringLib.dll zu laden. Wenn der Quellcode mit einem .NET Framework 1.1-Compiler kompiliert wird, wird eine BadImageFormatException durch die 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);
       }
    }
    
    open System.Reflection
    
    let title = "a tale of two cities"
          
    // Load assembly containing StateInfo type.
    let assem = Assembly.LoadFrom @".\StringLib.dll"
    
    // Get type representing StateInfo class.
    let stateInfoType = assem.GetType "StringLib"
    
    // Get Display method.
    let mi = stateInfoType.GetMethod "ToProperCase"
    
    // Call the Display method.
    let properTitle = 
       mi.Invoke(null, [| box title |]) :?> string
    
    printfn $"{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 dass die Assembly geladen werden soll, beide zielkompatible Versionen von .NET.

  • Die Komponenten Ihrer Anwendung zielen auf verschiedene Plattformen ab. 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 ermitteln. 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");
                }
             }
          }
       }
    }
    
    open System
    open System.IO
    open System.Reflection
    
    let args = Environment.GetCommandLineArgs()
    
    if args.Length = 1 then
        printfn "\nSyntax:   PlatformInfo <filename>\n"
    else
        printfn ""
        // Loop through files and display information about their platform.
        for i = 1 to args.Length - 1 do
            let fn = args[i]
            if not (File.Exists fn) then
                printfn $"File: {fn}"
                printfn "The file does not exist.\n"
            else
                try
                    let an = AssemblyName.GetAssemblyName fn
                    printfn $"Assembly: {an.Name}"
                    if an.ProcessorArchitecture = ProcessorArchitecture.MSIL then
                        printfn "Architecture: AnyCPU"
                    else
                        printfn $"Architecture: {an.ProcessorArchitecture}"
                    printfn ""
    
                with :? BadImageFormatException ->
                    printfn $"File: {fn}"
                    printfn "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