BadImageFormatException Osztály

Definíció

Névtér:

System

Szerelvények:

netstandard.dll, System.Runtime.dll

Forrás:

BadImageFormatException.cs

Az a kivétel, amely akkor jelentkezik, ha egy dinamikus hivatkozástár (DLL) vagy egy végrehajtható program fájlképe érvénytelen.

public ref class BadImageFormatException : SystemException

public class BadImageFormatException : SystemException

type BadImageFormatException = class
    inherit SystemException

Public Class BadImageFormatException
Inherits SystemException

Öröklődés

Object

Exception

SystemException

BadImageFormatException

Megjegyzések

Ez a kivétel akkor jelentkezik, ha egy dinamikus hivatkozástár (.dll fájl) vagy egy végrehajtható (.exe fájl) fájlformátuma nem felel meg a közös nyelvi futtatókörnyezet által elvárt formátumnak. A kivételt különösen a következő feltételek mellett kell kivenni:

• A .NET segédprogram egy korábbi verzióját( például ILDasm.exe vagy installutil.exe) egy olyan szerelvényhez használják, amelyet a .NET egy későbbi verziójával fejlesztettek ki.

  A kivétel elhárításához használja az eszköz azon verzióját, amely megfelel a szerelvény fejlesztéséhez használt .NET verziójának. Ehhez módosítani kell a Path környezeti változót, vagy meg kell adni egy teljes elérési utat a megfelelő végrehajthatóhoz.

• Nem felügyelt dinamikus csatolású kódtárat vagy végrehajtható fájlt próbál betölteni (például egy Windows rendszer DLL-ét), mintha .NET szerelvény lenne. Az alábbi példa ezt a Kernel32.dllbetöltésére szolgáló metódussal Assembly.LoadFile szemlélteti.

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

  A kivétel elhárításához a fejlesztési nyelv által biztosított funkciókkal érheti el a DLL-ben definiált metódusokat, például a Visual Basic Declare utasítását vagy a DllImportAttribute attribútumot a extern kulcsszóval C# és F# nyelven.

• A hivatkozási szerelvényt nem a csak tükröződés kontextusában próbálja betölteni. A probléma kétféleképpen oldható meg:

  • A megvalósítási szerelvényt a referenciaszerelvény helyett betöltheti.
  • A hivatkozási szerelvényt a metódus meghívásával töltheti be a Assembly.ReflectionOnlyLoad csak tükröződés kontextusában.

• A DLL vagy a végrehajtható fájl 64 bites szerelvényként van betöltve, de 32 bites szolgáltatásokat vagy erőforrásokat tartalmaz. Például com interop vagy calls metódusokra támaszkodik egy 32 bites dinamikus kapcsolatkódtárban.

  A kivétel elhárításához állítsa a projekt Platform céltulajdonságát x86-ra (x64 vagy AnyCPU helyett) és újrafordításra.

• Az alkalmazás összetevői a .NET különböző verzióival lettek létrehozva. Ez a kivétel általában akkor fordul elő, ha egy .NET Framework 2.0 SP1 vagy .NET Framework 3.5 használatával fejlesztett alkalmazás megpróbál betölteni egy szerelvényt, amelyet .NET Framework 4 vagy újabb használatával fejlesztettek ki. Lehet BadImageFormatException , hogy fordítási idő hibaként jelenthető, vagy a kivétel futásidőben is ki lehet dobni. Az alábbi példa egy StringLib egyetlen tagot tartalmazó osztályt határoz meg, ToProperCaseamely egy StringLib.dllnevű szerelvényben található.

  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
  

  Az alábbi példa tükröződés használatával tölt be egy StringLib.dllnevű szerelvényt. Ha a forráskódot egy .NET Framework 1.1 fordítóval fordítja le, a BadImageFormatException metódus Assembly.LoadFrom dob.

  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.
  

  A kivétel elhárításához győződjön meg arról, hogy az a szerelvény, amelynek a kódja fut, és amely a kivételt okozza, valamint a betöltendő szerelvényt, mindkettő a .NET kompatibilis verzióit célozza.

• Az alkalmazás összetevői különböző platformokat céloznak meg. Például arm-szerelvényeket próbál betölteni egy x86-os alkalmazásban. Az alábbi parancssori segédprogrammal meghatározhatja az egyes .NET szerelvények célplatformját. A fájlok listáját szóközzel tagolt listaként kell megadni a parancssorban.

  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
  

• A C++ végrehajtható fájlokra való tükrözés ezt a kivételt eredményezheti. Ezt valószínűleg az okozza, hogy a C++ fordító eltávolítja az áthelyezési címeket vagy a . Szakasz áthelyezése a végrehajtható fájlból. Ha meg szeretné őrizni a .relocation címet egy C++ végrehajtható fájlban, a csatoláskor adja meg a /fixed:nem értéket.

BadImageFormatException A HRESULT COR_E_BADIMAGEFORMATfüggvényt használja, amelynek értéke 0x8007000B.

A BadImageFormatException példány kezdeti tulajdonságainak listájáért tekintse meg a BadImageFormatException konstruktorokat.

Konstruktorok

Name	Description
BadImageFormatException()	Inicializálja a BadImageFormatException osztály új példányát.
BadImageFormatException(SerializationInfo, StreamingContext)	Elavult. Inicializálja az BadImageFormatException osztály új példányát szerializált adatokkal.
BadImageFormatException(String, Exception)	Inicializálja az BadImageFormatException osztály új példányát egy megadott hibaüzenettel és a kivétel okaként szolgáló belső kivételre mutató hivatkozással.
BadImageFormatException(String, String, Exception)	Inicializálja az BadImageFormatException osztály új példányát egy megadott hibaüzenettel és a kivétel okaként szolgáló belső kivételre mutató hivatkozással.
BadImageFormatException(String, String)	Inicializálja az BadImageFormatException osztály új példányát egy megadott hibaüzenettel és fájlnévvel.
BadImageFormatException(String)	Inicializálja az BadImageFormatException osztály új példányát egy megadott hibaüzenettel.

Tulajdonságok

Name	Description
Data	Lekéri a kulcs-/érték párok gyűjteményét, amelyek további, felhasználó által definiált információkat biztosítanak a kivételről. (Öröklődés forrása Exception)
FileName	Lekéri a kivételt okozó fájl nevét.
FusionLog	Lekéri azt a naplófájlt, amely leírja, hogy miért nem sikerült a szerelvénybetöltés.
HelpLink	Lekéri vagy beállítja a kivételhez társított súgófájlra mutató hivatkozást. (Öröklődés forrása Exception)
HResult	Lekéri vagy beállítja a HRESULT-ot, egy kódolt numerikus értéket, amely egy adott kivételhez van hozzárendelve. (Öröklődés forrása Exception)
InnerException	Lekéri az Exception aktuális kivételt okozó példányt. (Öröklődés forrása Exception)
Message	Lekéri a hibaüzenetet és a kivételt okozó fájl nevét.
Source	Lekéri vagy beállítja az alkalmazás vagy a hibát okozó objektum nevét. (Öröklődés forrása Exception)
StackTrace	Lekéri a hívásverem közvetlen kereteinek sztringképét. (Öröklődés forrása Exception)
TargetSite	Lekéri az aktuális kivételt okozó metódust. (Öröklődés forrása Exception)

Metódusok

Name	Description
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
GetBaseException()	Ha egy származtatott osztály felül van bírálva, egy Exception vagy több későbbi kivétel kiváltó okát adja vissza. (Öröklődés forrása Exception)
GetHashCode()	Ez az alapértelmezett kivonatoló függvény. (Öröklődés forrása Object)
GetObjectData(SerializationInfo, StreamingContext)	Elavult. Beállítja az SerializationInfo objektumot a fájlnévvel, a szerelvénygyorsítótár-naplóval és a további kivételadatokkal.
GetType()	Lekéri az aktuális példány futtatókörnyezeti típusát. (Öröklődés forrása Exception)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
ToString()	A kivétel teljes nevét, esetleg a hibaüzenetet, a belső kivétel nevét és a verem nyomkövetését adja vissza.

esemény

Name	Description
SerializeObjectState	Elavult. Akkor fordul elő, ha a kivétel szerializálva van egy kivételállapot-objektum létrehozásához, amely szerializált adatokat tartalmaz a kivételről. (Öröklődés forrása Exception)

Lásd még

• Exception
• Kivételek kezelése és kivetése