EntryPointNotFoundException Klasse

Definition

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

Eigenschaften

Methoden

Ereignisse

Gilt für:

Weitere Informationen

• Exception
• Behandeln und Auslösen von Ausnahmen