BadImageFormatException Klasa

Definicja

Wyjątek zgłaszany, gdy obraz pliku biblioteki łączy dynamicznych (DLL) lub program wykonywalny jest nieprawidłowy.

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
Dziedziczenie
BadImageFormatException
Dziedziczenie
BadImageFormatException
Atrybuty

Uwagi

Ten wyjątek jest zgłaszany, gdy format pliku biblioteki łączy dynamicznych (.dll pliku) lub pliku wykonywalnego (.exe pliku) nie jest zgodny z formatem oczekiwanym przez środowisko uruchomieniowe języka wspólnego. W szczególności wyjątek jest zgłaszany w następujących warunkach:

  • Wcześniejsza wersja narzędzia .NET, taka jak ILDasm.exe lub installutil.exe, jest używana z zestawem opracowanym w nowszej wersji platformy .NET.

    Aby rozwiązać ten wyjątek, użyj wersji narzędzia odpowiadającej wersji platformy .NET użytej do opracowania zestawu. Może to wymagać zmodyfikowania zmiennej środowiskowej Path lub podania w pełni kwalifikowanej ścieżki do poprawnego pliku wykonywalnego.

  • Próbujesz załadować niezarządzaną bibliotekę linków dynamicznych lub plik wykonywalny (na przykład bibliotekę DLL systemu Windows), tak jakby był to zestaw platformy .NET. Poniższy przykład ilustruje to przy użyciu Assembly.LoadFile metody ładowania 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.
    

    Aby rozwiązać ten wyjątek, uzyskaj dostęp do metod zdefiniowanych w dll przy użyciu funkcji udostępnianych przez język programowania, takich jak Declare instrukcja w Visual Basic lub DllImportAttribute atrybut ze extern słowem kluczowym w językach C# i F#.

  • Próbujesz załadować zestaw odwołania w kontekście innym niż kontekst tylko odbicia. Ten problem można rozwiązać na jeden z dwóch sposobów:

    • Zestaw implementacji można załadować, a nie zestaw referencyjny.
    • Zestaw odwołania można załadować w kontekście tylko odbicia, wywołując metodę Assembly.ReflectionOnlyLoad .
  • Biblioteka DLL lub plik wykonywalny jest ładowana jako zestaw 64-bitowy, ale zawiera 32-bitowe funkcje lub zasoby. Na przykład opiera się na międzyoperacie modelu COM lub wywołuje metody w 32-bitowej bibliotece linków dynamicznych.

    Aby rozwiązać ten wyjątek, ustaw właściwość docelową platformy projektu na wartość x86 (zamiast x64 lub AnyCPU) i ponownie skompiluj.

  • Składniki aplikacji zostały utworzone przy użyciu różnych wersji platformy .NET. Zazwyczaj ten wyjątek występuje, gdy aplikacja lub składnik opracowany przy użyciu .NET Framework 1.0 lub .NET Framework 1.1 próbuje załadować zestaw, który został opracowany przy użyciu .NET Framework 2.0 z dodatkiem SP1 lub nowszym albo gdy aplikacja opracowana przy użyciu .NET Framework 2.0 SP1 lub .NET Framework 3.5 próbuje załadować zestaw, który został opracowany przy użyciu .NET Framework 4 lub nowszej. Może BadImageFormatException być zgłaszany jako błąd czasu kompilacji lub wyjątek może zostać zgłoszony w czasie wykonywania. W poniższym przykładzie zdefiniowano klasę StringLib , która ma jeden element członkowski, ToProperCasei znajduje się w zestawie o nazwie 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
    

    W poniższym przykładzie użyto odbicia w celu załadowania zestawu o nazwie StringLib.dll. Jeśli kod źródłowy jest kompilowany przy użyciu kompilatora .NET Framework 1.1, BadImageFormatException metoda zwraca wartość .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.
    

    Aby rozwiązać ten wyjątek, upewnij się, że zestaw, którego kod jest wykonywany i który zgłasza wyjątek, oraz zestaw do załadowania, obie zgodne wersje platformy .NET.

  • Składniki aplikacji są przeznaczone dla różnych platform. Na przykład próbujesz załadować zestawy ARM w aplikacji x86. Aby określić platformy docelowe poszczególnych zestawów .NET, można użyć następującego narzędzia wiersza polecenia. Listę plików należy podać jako listę rozdzielaną spacjami w wierszu polecenia.

    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
    
  • Zastanawianie się nad plikami wykonywalnych języka C++ może zgłosić ten wyjątek. Jest to najprawdopodobniej spowodowane przez kompilator języka C++ usuwający adresy relokacji lub . Przenieś sekcję z pliku wykonywalnego. Aby zachować adres relokacji w pliku wykonywalnym C++, określ /fixed:no podczas łączenia.

BadImageFormatException używa hrESULT COR_E_BADIMAGEFORMAT, który ma wartość 0x8007000B.

Aby uzyskać listę początkowych wartości właściwości dla wystąpienia BadImageFormatExceptionprogramu , zobacz BadImageFormatException konstruktory.

Konstruktory

BadImageFormatException()

Inicjuje nowe wystąpienie klasy BadImageFormatException.

BadImageFormatException(SerializationInfo, StreamingContext)

Inicjuje nowe wystąpienie klasy BadImageFormatException z zserializowanymi danymi.

BadImageFormatException(String)

Inicjuje BadImageFormatException nowe wystąpienie klasy z określonym komunikatem o błędzie.

BadImageFormatException(String, Exception)

Inicjuje nowe wystąpienie BadImageFormatException klasy z określonym komunikatem o błędzie i odwołaniem do wyjątku wewnętrznego, który jest przyczyną tego wyjątku.

BadImageFormatException(String, String)

Inicjuje BadImageFormatException nowe wystąpienie klasy z określonym komunikatem o błędzie i nazwą pliku.

BadImageFormatException(String, String, Exception)

Inicjuje nowe wystąpienie BadImageFormatException klasy z określonym komunikatem o błędzie i odwołaniem do wyjątku wewnętrznego, który jest przyczyną tego wyjątku.

Właściwości

Data

Pobiera kolekcję par klucz/wartość, które zapewniają dodatkowe informacje zdefiniowane przez użytkownika dotyczące wyjątku.

(Odziedziczone po Exception)
FileName

Pobiera nazwę pliku, który powoduje ten wyjątek.

FusionLog

Pobiera plik dziennika opisujący, dlaczego ładowanie zestawu nie powiodło się.

HelpLink

Pobiera lub ustawia link do pliku pomocy skojarzonego z tym wyjątkiem.

(Odziedziczone po Exception)
HResult

Pobiera lub ustawia HRESULT, zakodowaną wartość liczbową przypisaną do określonego wyjątku.

(Odziedziczone po Exception)
InnerException

Exception Pobiera wystąpienie, które spowodowało bieżący wyjątek.

(Odziedziczone po Exception)
Message

Pobiera komunikat o błędzie i nazwę pliku, który spowodował ten wyjątek.

Source

Pobiera lub ustawia nazwę aplikacji lub obiektu, który powoduje błąd.

(Odziedziczone po Exception)
StackTrace

Pobiera reprezentację ciągu natychmiastowych ramek w stosie wywołań.

(Odziedziczone po Exception)
TargetSite

Pobiera metodę, która zgłasza bieżący wyjątek.

(Odziedziczone po Exception)

Metody

Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.

(Odziedziczone po Object)
GetBaseException()

Po przesłonięciu w klasie pochodnej funkcja zwraca Exception główną przyczynę co najmniej jednego kolejnego wyjątku.

(Odziedziczone po Exception)
GetHashCode()

Służy jako domyślna funkcja skrótu.

(Odziedziczone po Object)
GetObjectData(SerializationInfo, StreamingContext)

SerializationInfo Ustawia obiekt z nazwą pliku, dziennikiem pamięci podręcznej zestawów i dodatkowymi informacjami o wyjątku.

GetObjectData(SerializationInfo, StreamingContext)

Po zastąpieniu w klasie pochodnej ustawia SerializationInfo element z informacjami o wyjątku.

(Odziedziczone po Exception)
GetType()

Pobiera typ środowiska uruchomieniowego bieżącego wystąpienia.

(Odziedziczone po Exception)
MemberwiseClone()

Tworzy płytkią kopię bieżącego Objectelementu .

(Odziedziczone po Object)
ToString()

Zwraca w pełni kwalifikowaną nazwę tego wyjątku i prawdopodobnie komunikat o błędzie, nazwę wyjątku wewnętrznego i ślad stosu.

Zdarzenia

SerializeObjectState
Nieaktualne.

Występuje, gdy wyjątek jest serializowany w celu utworzenia obiektu stanu wyjątku zawierającego serializowane dane o wyjątku.

(Odziedziczone po Exception)

Dotyczy

Zobacz też