BadImageFormatException Třída

Reference

Definice

Obor názvů:: System

Sestavení:: System.Runtime.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

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: Object

Exception
BadImageFormatException

Dědičnost: Object

Exception

SystemException
BadImageFormatException

Atributy: SerializableAttribute ComVisibleAttribute

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

Sdílet prostřednictvím