Sdílet prostřednictvím


BadImageFormatException Třída

Definice

Výjimka, která je vyvolán v případě, že obrázek souboru dynamické knihovny (DLL) nebo spustitelného programu je neplatný.

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
Dědičnost
BadImageFormatException
Dědičnost
BadImageFormatException
Atributy

Poznámky

Tato výjimka se vyvolá, pokud formát souboru knihovny dynamického propojení (soubor .dll) nebo spustitelného souboru (soubor .exe) neodpovídá formátu očekávanému modulem Common Language Runtime. Výjimka se vyvolá zejména za následujících podmínek:

  • Starší verze nástroje .NET, například ILDasm.exe nebo installutil.exe, se používá se sestavením, které bylo vyvinuto s novější verzí .NET.

    Chcete-li tuto výjimku vyřešit, použijte verzi nástroje, která odpovídá verzi rozhraní .NET, která byla použita k vývoji sestavení. To může vyžadovat úpravu Path proměnné prostředí nebo poskytnutí plně kvalifikované cesty ke správnému spustitelnému souboru.

  • Pokoušíte se načíst nespravovanou dynamickou knihovnu nebo spustitelný soubor (například systémovou knihovnu DLL systému Windows), jako by šlo o sestavení .NET. Následující příklad to ilustruje pomocí Assembly.LoadFile metody pro načtení Kernel32.dll.

    // 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.
    

    Pokud chcete tuto výjimku vyřešit, získejte přístup k metodám definovaným v knihovně DLL pomocí funkcí poskytovaných vaším vývojovým jazykem, jako Declare je příkaz v jazyce Visual Basic nebo DllImportAttribute atribut s klíčovým slovem extern v jazyce C# a F#.

  • Pokoušíte se načíst referenční sestavení v jiném kontextu, než je kontext jen pro reflexi. Tento problém můžete vyřešit jedním ze dvou způsobů:

    • Místo referenčního sestavení můžete načíst sestavení implementace.
    • Referenční sestavení můžete načíst v kontextu jen pro reflexi voláním Assembly.ReflectionOnlyLoad metody .
  • Knihovna DLL nebo spustitelný soubor je načten jako 64bitové sestavení, ale obsahuje 32bitové funkce nebo prostředky. Spoléhá například na zprostředkovatele komunikace COM nebo volá metody v 32bitové knihovně dynamického propojení.

    Pokud chcete tuto výjimku vyřešit, nastavte vlastnost cílové platformy projektu na x86 (místo x64 nebo AnyCPU) a znovu zkompilujte.

  • Komponenty vaší aplikace byly vytvořeny pomocí různých verzí .NET. K této výjimce obvykle dochází, když se aplikace nebo komponenta vyvinutá pomocí rozhraní .NET Framework 1.0 nebo .NET Framework 1.1 pokusí načíst sestavení, které bylo vyvinuto pomocí rozhraní .NET Framework 2.0 SP1 nebo novější, nebo když se aplikace vyvinutá pomocí rozhraní .NET Framework 2.0 SP1 nebo .NET Framework 3.5 pokusí načíst sestavení, které bylo vyvinuto pomocí rozhraní .NET Framework 4 nebo novější. Může BadImageFormatException být hlášena jako chyba při kompilaci nebo může být vyvolán výjimka za běhu. Následující příklad definuje StringLib třídu, která má jeden člen, ToProperCasea která se nachází v sestavení s názvem StringLib.dll.

    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
    

    Následující příklad používá reflexi k načtení sestavení s názvem StringLib.dll. Pokud je zdrojový kód kompilován pomocí kompilátoru rozhraní .NET Framework 1.1, BadImageFormatException vyvolá Assembly.LoadFrom metoda .

    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.
    

    Chcete-li tuto výjimku vyřešit, ujistěte se, že sestavení, jehož kód se spouští a které vyvolá výjimku, a sestavení, které se má načíst, jsou cílové kompatibilní verze rozhraní .NET.

  • Komponenty vaší aplikace cílí na různé platformy. Například se pokoušíte načíst sestavení ARM v aplikaci x86. K určení cílových platforem jednotlivých sestavení .NET můžete použít následující nástroj příkazového řádku. Seznam souborů by měl být uveden jako seznam oddělený mezerami na příkazovém řádku.

    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
    
  • Reflexe spustitelných souborů C++ může vyvolat tuto výjimku. Příčinou je s největší pravděpodobností odstranění adres přemístění kompilátorem jazyka C++ nebo . Přemístit oddíl ze spustitelného souboru. Chcete-li zachovat adresu .relocation ve spustitelném souboru jazyka C++, při propojování zadejte /fixed:no.

BadImageFormatException používá hodnotu HRESULT COR_E_BADIMAGEFORMAT, která má hodnotu 0x8007000B.

Seznam počátečních hodnot vlastností pro instanci nástroje najdete v BadImageFormatException konstruktorechBadImageFormatException.

Konstruktory

BadImageFormatException()

Inicializuje novou instanci BadImageFormatException třídy.

BadImageFormatException(SerializationInfo, StreamingContext)

Inicializuje novou instanci třídy BadImageFormatException se serializovanými daty.

BadImageFormatException(String)

Inicializuje novou instanci BadImageFormatException třídy se zadanou chybovou zprávou.

BadImageFormatException(String, Exception)

Inicializuje novou instanci BadImageFormatException třídy se zadanou chybovou zprávou a odkazem na vnitřní výjimku, která je příčinou této výjimky.

BadImageFormatException(String, String)

Inicializuje novou instanci BadImageFormatException třídy se zadanou chybovou zprávou a názvem souboru.

BadImageFormatException(String, String, Exception)

Inicializuje novou instanci BadImageFormatException třídy se zadanou chybovou zprávou a odkazem na vnitřní výjimku, která je příčinou této výjimky.

Vlastnosti

Data

Získá kolekci párů klíč/hodnota, které poskytují další uživatelem definované informace o výjimce.

(Zděděno od Exception)
FileName

Získá název souboru, který způsobuje tuto výjimku.

FusionLog

Získá soubor protokolu, který popisuje, proč načtení sestavení selhalo.

HelpLink

Získá nebo nastaví odkaz na soubor nápovědy přidružené k této výjimce.

(Zděděno od Exception)
HResult

Získá nebo nastaví HRESULT, kódovanou číselnou hodnotu, která je přiřazena ke konkrétní výjimce.

(Zděděno od Exception)
InnerException

Exception Získá instanci, která způsobila aktuální výjimku.

(Zděděno od Exception)
Message

Získá chybovou zprávu a název souboru, který způsobil tuto výjimku.

Source

Získá nebo nastaví název aplikace nebo objektu, který způsobuje chybu.

(Zděděno od Exception)
StackTrace

Získá řetězcovou reprezentaci okamžitých rámců v zásobníku volání.

(Zděděno od Exception)
TargetSite

Získá metodu, která vyvolá aktuální výjimku.

(Zděděno od Exception)

Metody

Equals(Object)

Určí, zda se zadaný objekt rovná aktuálnímu objektu.

(Zděděno od Object)
GetBaseException()

Při přepsání v odvozené třídě vrátí Exception hodnotu, která je původní příčinou jedné nebo více následných výjimek.

(Zděděno od Exception)
GetHashCode()

Slouží jako výchozí hashovací funkce.

(Zděděno od Object)
GetObjectData(SerializationInfo, StreamingContext)

Nastaví objekt s SerializationInfo názvem souboru, protokolem mezipaměti sestavení a dalšími informacemi o výjimce.

GetObjectData(SerializationInfo, StreamingContext)

Při přepsání v odvozené třídě nastaví SerializationInfo s informacemi o výjimce.

(Zděděno od Exception)
GetType()

Získá typ modulu runtime aktuální instance.

(Zděděno od Exception)
MemberwiseClone()

Vytvoří mělkou kopii aktuálního Objectsouboru .

(Zděděno od Object)
ToString()

Vrátí plně kvalifikovaný název této výjimky a pravděpodobně chybovou zprávu, název vnitřní výjimky a trasování zásobníku.

Událost

SerializeObjectState
Zastaralé.

Nastane, když je výjimka serializována k vytvoření objektu stavu výjimky, který obsahuje serializovaná data o výjimce.

(Zděděno od Exception)

Platí pro

Viz také