EntryPointNotFoundException Klasse

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Source:: EntryPointNotFoundException.cs

Source:: EntryPointNotFoundException.cs

Source:: EntryPointNotFoundException.cs

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Die Ausnahme, die ausgelöst wird, wenn der Versuch zum Laden einer Klasse aufgrund einer fehlender Entrymethode fehlschlägt.

public ref class EntryPointNotFoundException : TypeLoadException

public class EntryPointNotFoundException : TypeLoadException

[System.Serializable]
public class EntryPointNotFoundException : TypeLoadException

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class EntryPointNotFoundException : TypeLoadException

type EntryPointNotFoundException = class
    inherit TypeLoadException

[<System.Serializable>]
type EntryPointNotFoundException = class
    inherit TypeLoadException

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type EntryPointNotFoundException = class
    inherit TypeLoadException

Public Class EntryPointNotFoundException
Inherits TypeLoadException

Vererbung: Object

Exception

SystemException

TypeLoadException
EntryPointNotFoundException

Attribute: SerializableAttribute ComVisibleAttribute

Hinweise

Eine EntryPointNotFoundException Ausnahme wird ausgelöst, wenn die Common Language Runtime keine Assembly laden kann, da sie den Einstiegspunkt der Assembly nicht identifizieren kann. Diese Ausnahme kann unter den folgenden Bedingungen ausgelöst werden:

Die Common Language Runtime kann keinen Anwendungseinstiegspunkt (in der Regel eine Main Methode) in einer ausführbaren Assembly finden. Der Anwendungseinstiegspunkt muss eine globale Oder static -Methode sein, die entweder über keine Parameter oder ein Zeichenfolgenarray als einzigen Parameter verfügt. Der Einstiegspunkt kann zurückgeben voidoder einen Int32 Exitcode zurückgeben UInt32 . Eine Anwendungsassembly kann nicht mehr als einen Einstiegspunkt definieren.

Der Aufruf einer Funktion in einer Windows-DLL kann nicht aufgelöst werden, da die Funktion nicht gefunden werden kann. Im folgenden Beispiel wird eine EntryPointNotFoundException Ausnahme ausgelöst, weil User32.dll keine Funktion mit dem Namen GetMyNumberenthält.

using System;
using System.Runtime.InteropServices;

public class Example
{
   [DllImport("user32.dll")]
   public static extern int GetMyNumber();

   public static void Main()
   {
      try {
         int number = GetMyNumber();
      }
      catch (EntryPointNotFoundException e) {
         Console.WriteLine("{0}:\n   {1}", e.GetType().Name,
                           e.Message);
      }
   }
}
// The example displays the following output:
//    EntryPointNotFoundException:
//       Unable to find an entry point named 'GetMyNumber' in DLL 'User32.dll'.

open System
open System.Runtime.InteropServices

[<DllImport "user32.dll">]
extern int GetMyNumber()

try
    let number = GetMyNumber()
    ()
with :? EntryPointNotFoundException as e ->
    printfn $"{e.GetType().Name}:\n   {e.Message}"

// The example displays the following output:
//    EntryPointNotFoundException:
//       Unable to find an entry point named 'GetMyNumber' in DLL 'User32.dll'.

Module Example
    Declare Auto Function GetMyNumber Lib "User32.dll" () As Integer

   Public Sub Main()
      Try
         Dim number As Integer = GetMyNumber()
      Catch e As EntryPointNotFoundException
         Console.WriteLine("{0}:{2}   {1}", e.GetType().Name,  
                           e.Message, vbCrLf)
      End Try   
   End Sub
End Module
' The example displays the following output:
'    EntryPointNotFoundException:
'       Unable to find an entry point named 'GetMyNumber' in DLL 'User32.dll'.

Der Aufruf einer Funktion in einer Windows-DLL kann nicht aufgelöst werden, da der im Methodenaufruf verwendete Name nicht mit einem Namen in der Assembly übereinstimmt. Häufig tritt dies auf, weil das DllImportAttribute.ExactSpelling Feld entweder implizit oder explizit auf truefestgelegt ist, die aufgerufene Methode einen oder mehrere Zeichenfolgenparameter enthält und sowohl eine ANSI- als auch eine Unicode-Version aufweist und der im Methodenaufruf verwendete Name nicht dem Namen dieser ANSI- oder Unicode-Version entspricht. Das folgende Beispiel zeigt eine Veranschaulichung, indem versucht wird, die Windows-Funktion MessageBox in User32.dll aufzurufen. Da die erste Methodendefinition für das Zeichenfolgen marshalling angibt CharSet.Unicode , sucht die allgemeine Sprache nach der Breitzeichenversion der Funktion, MessageBoxWanstelle des im Methodenaufruf MessageBoxverwendeten Namens. Die zweite Methodendefinition behebt dieses Problem, indem anstelle der MessageBox -Funktion aufgerufen MessageBoxW wird.

using System;
using System.Runtime.InteropServices;

public class Example
{
   [DllImport("user32.dll", CharSet = CharSet.Unicode, ExactSpelling = true )]
   public static extern int MessageBox(IntPtr hwnd, String text, String caption, uint type);

   [DllImport("user32.dll", CharSet = CharSet.Unicode, ExactSpelling = true )]
   public static extern int MessageBoxW(IntPtr hwnd, String text, String caption, uint type);

   public static void Main()
   {
      try {
         MessageBox(new IntPtr(0), "Calling the MessageBox Function", "Example", 0);
      }
      catch (EntryPointNotFoundException e) {
         Console.WriteLine("{0}:\n   {1}", e.GetType().Name,
                           e.Message);
      }

      try {
         MessageBoxW(new IntPtr(0), "Calling the MessageBox Function", "Example", 0);
      }
      catch (EntryPointNotFoundException e) {
         Console.WriteLine("{0}:\n   {1}", e.GetType().Name,
                           e.Message);
      }
   }
}

open System
open System.Runtime.InteropServices

[<DllImport("user32.dll", CharSet = CharSet.Unicode, ExactSpelling = true )>]
extern int MessageBox(IntPtr hwnd, String text, String caption, uint ``type``)

[<DllImport("user32.dll", CharSet = CharSet.Unicode, ExactSpelling = true )>]
extern int MessageBoxW(IntPtr hwnd, String text, String caption, uint ``type``)

try
    MessageBox(IntPtr 0, "Calling the MessageBox Function", "Example", 0u)
    |> ignore
with :? EntryPointNotFoundException as e ->
    printfn $"{e.GetType().Name}:\n   {e.Message}"

try
    MessageBoxW(IntPtr 0, "Calling the MessageBox Function", "Example", 0u)
    |> ignore
with :? EntryPointNotFoundException as e ->
    printfn $"{e.GetType().Name}:\n   {e.Message}"

Module Example
   Declare Unicode Function MessageBox Lib "User32.dll" Alias "MessageBox" (
      ByVal hWnd As IntPtr, ByVal txt As String, ByVal caption As String, 
      ByVal typ As UInteger) As Integer  

   Declare Unicode Function MessageBox2 Lib "User32.dll" Alias "MessageBoxW" (  
      ByVal hWnd As IntPtr, ByVal txt As String, ByVal caption As String, 
      ByVal typ As UInteger) As Integer  
      
   Public Sub Main()
      Try
         MessageBox(IntPtr.Zero, "Calling the MessageBox Function", "Example", 0 )
      Catch e As EntryPointNotFoundException
         Console.WriteLine("{0}:{2}   {1}", e.GetType().Name,  
                           e.Message, vbCrLf)
      End Try

      Try
         MessageBox2(IntPtr.Zero, "Calling the MessageBox Function", "Example", 0 )
      Catch e As EntryPointNotFoundException
         Console.WriteLine("{0}:{2}   {1}", e.GetType().Name,  
                           e.Message, vbCrLf)
      End Try

   End Sub
End Module

Sie versuchen, eine Funktion in einer Dynamischen Linkbibliothek mit ihrem einfachen Namen und nicht mit ihrem dekorierten Namen aufzurufen. In der Regel generiert der C++-Compiler einen dekorierten Namen für DLL-Funktionen. Der folgende C++-Code definiert beispielsweise eine Funktion namens Double in einer Bibliothek namens TestDll.dll.

__declspec(dllexport) int Double(int number)
{
    return number * 2;
}

Wenn der Code im folgenden Beispiel versucht, die Funktion aufzurufen, wird eine EntryPointNotFoundException Ausnahme ausgelöst, da die Double Funktion nicht gefunden werden kann.

using System;
using System.Runtime.InteropServices;

public class Example
{
   [DllImport("TestDll.dll")]
   public static extern int Double(int number);

   public static void Main()
   {
      Console.WriteLine(Double(10));
   }
}
// The example displays the following output:
//    Unhandled Exception: System.EntryPointNotFoundException: Unable to find
//    an entry point named 'Double' in DLL '.\TestDll.dll'.
//       at Example.Double(Int32 number)
//       at Example.Main()

open System
open System.Runtime.InteropServices

[<DllImport "TestDll.dll">]
extern int Double(int number)

printfn $"{Double 10}"
// The example displays the following output:
//    Unhandled Exception: System.EntryPointNotFoundException: Unable to find
//    an entry point named 'Double' in DLL '.\TestDll.dll'.
//       at Example.Double(Int32 number)
//       at Example.Main()

Module Example
   Public Declare Function DoubleNum Lib ".\TestDll.dll" Alias "Double" _
                  (ByVal number As Integer) As Integer
   
   Public Sub Main()
      Console.WriteLine(DoubleNum(10))
   End Sub
End Module
' The example displays the following output:
'    Unhandled Exception: System.EntryPointNotFoundException: Unable to find an 
'    entry point named 'Double' in DLL '.\TestDll.dll'.
'       at Example.Double(Int32 number)
'       at Example.Main()

Wenn die Funktion jedoch mit ihrem dekorierten Namen aufgerufen wird (in diesem Fall), ?Double@@YAHH@Zist der Funktionsaufruf erfolgreich, wie im folgenden Beispiel gezeigt.

using System;
using System.Runtime.InteropServices;

public class Example
{
   [DllImport("TestDll.dll", EntryPoint = "?Double@@YAHH@Z")]
   public static extern int Double(int number);

   public static void Main()
   {
      Console.WriteLine(Double(10));
   }
}
// The example displays the following output:
//    20

open System
open System.Runtime.InteropServices

[<DllImport("TestDll.dll", EntryPoint = "?Double@@YAHH@Z")>]
extern int Double(int number)

printfn $"{Double 10}"
// The example displays the following output:
//    20

Module Example
   Public Declare Function DoubleNum Lib ".\TestDll.dll" Alias "?Double@@YAHH@Z" _
                  (ByVal number As Integer) As Integer
   
   Public Sub Main()
      Console.WriteLine(DoubleNum(10))
   End Sub
End Module
' The example displays the following output:
'    20

Sie können die dekorierten Namen von Funktionen finden, die von einer DLL exportiert werden, indem Sie ein Hilfsprogramm wie Dumpbin.exe verwenden.

Sie versuchen, eine Methode in einer verwalteten Assembly aufzurufen, als wäre sie eine nicht verwaltete Bibliothek für dynamische Verknüpfungen. Um dies in Aktion zu sehen, kompilieren Sie das folgende Beispiel in eine Assembly mit dem Namen StringUtilities.dll.

using System;

public static class StringUtilities
{
   public static String SayGoodMorning(String name)
   {
      return String.Format("A top of the morning to you, {0}!", name);
   }
}

module StringUtilities

let SayGoodMorning name =
    $"A top of the morning to you, %s{name}!"

Module StringUtilities
   Public Function SayGoodMorning(name As String) As String
      Return String.Format("A top of the morning to you, {0}!", name)
   End Function
End Module

Kompilieren Sie dann das folgende Beispiel, und führen Sie das folgende Beispiel aus, bei dem versucht wird, die StringUtilities.SayGoodMorning Methode in der StringUtilities.dll Bibliothek für dynamische Verknüpfungen aufzurufen, als ob es sich um nicht verwalteten Code handelt. Das Ergebnis ist eine EntryPointNotFoundException Ausnahme.

using System;
using System.Runtime.InteropServices;

public class Example
{
   [DllImport("StringUtilities.dll", CharSet = CharSet.Unicode )]
   public static extern String SayGoodMorning(String name);

   public static void Main()
   {
      Console.WriteLine(SayGoodMorning("Dakota"));
   }
}
// The example displays the following output:
//    Unhandled Exception: System.EntryPointNotFoundException: Unable to find an entry point
//    named 'GoodMorning' in DLL 'StringUtilities.dll'.
//       at Example.GoodMorning(String& name)
//       at Example.Main()

open System
open System.Runtime.InteropServices

[<DllImport("StringUtilities.dll", CharSet = CharSet.Unicode )>]
extern String SayGoodMorning(String name)

printfn $"""{SayGoodMorning "Dakota"}"""
// The example displays the following output:
//    Unhandled Exception: System.EntryPointNotFoundException: Unable to find an entry point
//    named 'GoodMorning' in DLL 'StringUtilities.dll'.
//       at Example.GoodMorning(String& name)
//       at Example.Main()

Module Example
   Declare Unicode Function GoodMorning Lib "StringUtilities.dll" (
      ByVal name As String) As String  

   Public Sub Main()
      Console.WriteLine(SayGoodMorning("Dakota"))
   End Sub
End Module
' The example displays the following output:
'    Unhandled Exception: System.EntryPointNotFoundException: Unable to find an entry point 
'    named 'GoodMorning' in DLL 'StringUtilities.dll'.
'       at Example.GoodMorning(String& name)
'       at Example.Main()

Um die Ausnahme zu beseitigen, fügen Sie einen Verweis auf die verwaltete Assembly hinzu, und greifen Sie genauso auf die StringUtilities.SayGoodMorning Methode zu, wie Sie auf jede andere Methode in verwaltetem Code zugreifen würden, wie im folgenden Beispiel.

using System;

public class Example
{
   public static void Main()
   {
       Console.WriteLine(StringUtilities.SayGoodMorning("Dakota"));
   }
}
// The example displays the following output:
//        A top of the morning to you, Dakota!

printfn $"""{StringUtilities.SayGoodMorning "Dakota"}"""
// The example displays the following output:
//        A top of the morning to you, Dakota!

Module Example
   Public Sub Main()
      Console.WriteLine(StringUtilities.SayGoodMorning("Dakota"))
   End Sub
End Module
' The example displays the following output:
'       A top of the morning to you, Dakota!

Sie versuchen, eine Methode in einer COM-DLL aufzurufen, als wäre sie eine Windows-DLL. Um auf eine COM-DLL zuzugreifen, wählen Sie in Visual Studio die Option Verweis hinzufügen aus, um einen Verweis auf das Projekt hinzuzufügen, und wählen Sie dann auf der Registerkarte COM die Typbibliothek aus.

Eine Liste der anfänglichen Eigenschaftswerte für eine Instanz von EntryPointNotFoundException, finden Sie unter den EntryPointNotFoundException Konstruktoren.

Konstruktoren

EntryPointNotFoundException()	Initialisiert eine neue Instanz der EntryPointNotFoundException-Klasse.
EntryPointNotFoundException(SerializationInfo, StreamingContext)	Veraltet. Initialisiert eine neue Instanz der EntryPointNotFoundException-Klasse mit serialisierten Daten.
EntryPointNotFoundException(String)	Initialisiert eine neue Instanz der EntryPointNotFoundException-Klasse mit einer angegebenen Fehlermeldung.
EntryPointNotFoundException(String, Exception)	Initialisiert eine neue Instanz der EntryPointNotFoundException-Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat.

Eigenschaften

Data	Ruft eine Auflistung von Schlüssel-Wert-Paaren ab, die zusätzliche benutzerdefinierte Informationen zur Ausnahme bereitstellen. (Geerbt von Exception)
HelpLink	Ruft einen Link zur Hilfedatei ab, die dieser Ausnahme zugeordnet ist, oder legt einen Link fest. (Geerbt von Exception)
HResult	Ruft HRESULT ab oder legt HRESULT fest. Dies ist ein codierter Wert, der einer bestimmten Ausnahme zugeordnet ist. (Geerbt von Exception)
InnerException	Ruft die Exception-Instanz ab, die die aktuelle Ausnahme verursacht hat. (Geerbt von Exception)
Message	Ruft die Fehlermeldung für diese Ausnahme ab. (Geerbt von TypeLoadException)
Source	Gibt den Namen der Anwendung oder des Objekts zurück, die bzw. das den Fehler verursacht hat, oder legt diesen fest. (Geerbt von Exception)
StackTrace	Ruft eine Zeichenfolgendarstellung der unmittelbaren Frames in der Aufrufliste ab. (Geerbt von Exception)
TargetSite	Ruft die Methode ab, die die aktuelle Ausnahme auslöst. (Geerbt von Exception)
TypeName	Ruft den vollqualifizierten Namen des Typs ab, der die Ausnahme verursacht hat. (Geerbt von TypeLoadException)

Methoden

Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetBaseException()	Gibt beim Überschreiben in einer abgeleiteten Klasse eine Exception zurück, die die Grundursache für eine oder mehrere nachfolgende Ausnahmen ist. (Geerbt von Exception)
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetObjectData(SerializationInfo, StreamingContext)	Veraltet. Legt das SerializationInfo-Objekt mit dem Klassennamen, Methodennamen, der Ressourcen-ID und zusätzlichen Informationen zur Ausnahme fest. (Geerbt von TypeLoadException)
GetType()	Ruft den Laufzeittyp der aktuellen Instanz ab. (Geerbt von Exception)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
ToString()	Erstellt eine Zeichenfolgendarstellung der aktuellen Ausnahme und gibt diese zurück. (Geerbt von Exception)

Ereignisse

SerializeObjectState

Veraltet.

Tritt auf, wenn eine Ausnahme serialisiert wird, um ein Ausnahmezustandsobjekt mit serialisierten Daten über die Ausnahme zu erstellen.

(Geerbt von Exception)

Gilt für: