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 einen Anwendungseinstiegspunkt (in der Regel eine Main Methode) in einer ausführbaren Assembly nicht finden. Der Anwendungseinstiegspunkt muss eine globale oder static Methode sein, die entweder keine Parameter oder ein Zeichenfolgenarray als einzigen Parameter aufweist. Der Einstiegspunkt kann zurückgeben voidoder einen Int32 Code zurückgeben oder UInt32 beenden. 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, da 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 übereinstimmt, der in der Assembly gefunden wurde. Häufig tritt dies auf, da das DllImportAttribute.ExactSpelling Feld implizit oder explizit auf festgelegt trueist, die aufgerufene Methode einen oder mehrere Zeichenfolgenparameter enthält und sowohl eine ANSI- als auch eine Unicode-Version aufweist, und der name, der im Methodenaufruf verwendet wird, entspricht nicht dem Namen dieser ANSI- oder Unicode-Version. Das folgende Beispiel zeigt eine Abbildung, indem versucht wird, die Funktion Windows MessageBox in User32.dllaufzurufen. Da die erste Methodendefinition für die Zeichenfolgenmarsing angibtCharSet.Unicode, sucht die allgemeine Sprache nach der breitzeichenigen Version der Funktion, MessageBoxWanstelle des Namens, der im Methodenaufruf verwendet wird. MessageBox Die zweite Methodendefinition korrigiert dieses Problem, indem anstelle MessageBoxW der MessageBox Funktion aufgerufen 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 anhand des einfachen Namens und nicht anhand des eingerichteten Namens aufzurufen. In der Regel generiert der C++-Compiler einen eingerichteten Namen für DLL-Funktionen. Der folgende C++-Code definiert beispielsweise eine Funktion, die in einer Bibliothek mit dem Namen TestDll.dllbenannt Double ist.

  __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 mithilfe ihres dekorierten Namens aufgerufen wird (in diesem Fall ?Double@@YAHH@Z), wird der Funktionsaufruf erfolgreich ausgeführt, 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 finden die verzierten Namen von Funktionen, die von einer DLL exportiert werden, mithilfe eines Dienstprogramms wie Dumpbin.exe.

• Sie versuchen, eine Methode in einer verwalteten Assembly aufzurufen, als wäre sie eine nicht verwaltete Dynamic Link Library. Um dies in Aktion zu sehen, kompilieren Sie das folgende Beispiel zu einer 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 Und ausführen Sie dann das folgende Beispiel, das versucht, die StringUtilities.SayGoodMorning Methode in der StringUtilities.dll Dynamic Link Library aufzurufen, als wäre es nicht verwalteter Code. 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 wie StringUtilities.SayGoodMorning auf jede andere Methode in verwaltetem Code zu, wie im folgenden Beispiel gezeigt.

  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 es eine Windows DLL. Um auf eine COM-DLL zuzugreifen, wählen Sie die Option Verweis in Visual Studio aus, um einen Verweis auf das Projekt hinzuzufügen, und wählen Sie dann die Typbibliothek auf der Registerkarte COM aus.

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

Weitere Informationen

• Exception
• Behandeln und Auslösen von Ausnahmen