BadImageFormatException Třída

Definice

Obor názvů:: System

Sestavení:: mscorlib.dll, System.Runtime.dll

Sestavení:: netstandard.dll, System.Runtime.dll

Sestavení:: System.Runtime.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Zdroj:: BadImageFormatException.cs

Zdroj:: BadImageFormatException.cs

Zdroj:: BadImageFormatException.cs

Zdroj:: BadImageFormatException.cs

Zdroj:: BadImageFormatException.cs

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á se vyvolá, když je obrázek souboru dynamické knihovny odkazů (DLL) nebo spustitelný program 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 dynamické knihovny odkazů (.dll soubor) nebo spustitelný soubor (.exe soubor) neodpovídá formátu, který očekává modul CLR (Common Language Runtime). Zejména je výjimka vyvolán za následujících podmínek:

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

Chcete-li tuto výjimku vyřešit, použijte verzi nástroje, která odpovídá verzi .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 Windows systémovou knihovnu DLL), jako by se jednalo 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, přejděte k metodám definovaným v knihovně DLL pomocí funkcí poskytovaných vaším vývojovým jazykem, jako je například příkaz Declare v Visual Basic nebo atribut DllImportAttribute 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 reflexe. 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 pouze v kontextu reflexe voláním Assembly.ReflectionOnlyLoad metody.
Knihovna DLL nebo spustitelný soubor se načte jako 64bitové sestavení, ale obsahuje 32bitové funkce nebo prostředky. Například spoléhá na zprostředkovatele komunikace modelu COM nebo volání metod v 32bitové dynamické knihovně odkazů.

Pokud chcete tuto výjimku vyřešit, nastavte cílovou vlastnost projektu na hodnotu x86 (místo x64 nebo AnyCPU) a rekompilujte ji.

Komponenty vaší aplikace byly vytvořeny pomocí různých verzí .NET. K této výjimce obvykle dochází, když aplikace vyvinutá pomocí .NET Framework 2.0 SP1 nebo .NET Framework 3.5 se pokusí načíst sestavení vyvinuté pomocí .NET Framework 4 nebo novější. Tato BadImageFormatException chyba může být hlášena jako chyba v době kompilace 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 zkompilován kompilátorem .NET Framework 1.1, vyvolá BadImageFormatException metodou Assembly.LoadFrom.

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 je spuštěn a který vyvolá výjimku, a sestavení, které se má načíst, obě cílové kompatibilní verze .NET.

Komponenty vaší aplikace cílí na různé platformy. Například se pokoušíte načíst sestavení ARM v aplikaci x86. Pomocí následujícího nástroje příkazového řádku můžete určit cílové platformy jednotlivých .NET sestavení. Seznam souborů by měl být k dispozici 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

Reflektování spustitelných souborů C++ může vyvolat tuto výjimku. Příčinou je pravděpodobně odstranění adres přemístění nebo adresy kompilátoru C++ . Znovu přidělit oddíl ze spustitelného souboru. Chcete-li zachovat adresu .přemístění ve spustitelném souboru C++, při propojení zadejte /fixed:no.

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

Seznam počátečních hodnot vlastností pro instanci BadImageFormatExceptionnaleznete v konstruktoru BadImageFormatException.

Konstruktory

Name	Description
BadImageFormatException()	Inicializuje novou instanci BadImageFormatException třídy.
BadImageFormatException(SerializationInfo, StreamingContext)	Zastaralé. Inicializuje novou instanci BadImageFormatException třídy serializovanými daty.
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, 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)	Inicializuje novou instanci BadImageFormatException třídy se zadanou chybovou zprávou.

Vlastnosti

Name	Description
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ězcové znázornění 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

Name	Description
Equals(Object)	Určuje, zda je zadaný objekt roven aktuálnímu objektu. (Zděděno od Object)
GetBaseException()	Při přepsání v odvozené třídě vrátí Exception to, že je původní příčinou jedné nebo více následných výjimek. (Zděděno od Exception)
GetHashCode()	Slouží jako výchozí funkce hash. (Zděděno od Object)
GetObjectData(SerializationInfo, StreamingContext)	Zastaralé. SerializationInfo Nastaví objekt s názvem souboru, protokolem mezipaměti sestavení a dalšími informacemi o výjimce.
GetType()	Získá typ modulu runtime aktuální instance. (Zděděno od Exception)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (Zděděno od Object)
ToString()	Vrátí plně kvalifikovaný název této výjimky a případně chybovou zprávu, název vnitřní výjimky a trasování zásobníku.

Událost

Name	Description
SerializeObjectState	Zastaralé. Nastane, když je výjimka serializována vytvořit objekt stavu výjimky, který obsahuje serializovaná data o výjimce. (Zděděno od Exception)

Platí pro

Viz také

Váš názor

Byla tato stránka užitečná?