EntryPointNotFoundException Classe

Définition

Exception levée lorsqu'une tentative de chargement d'une classe échoue en raison de l'absence de méthode d'entrée.The exception that is thrown when an attempt to load a class fails due to the absence of an entry method.

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
Héritage
EntryPointNotFoundException
Attributs

Remarques

Une EntryPointNotFoundException exception est levée lorsque l’Common Language Runtime ne parvient pas à charger un assembly, car il ne peut pas identifier le point d’entrée de l’assembly.An EntryPointNotFoundException exception is thrown when the common language runtime is unable to load an assembly because it cannot identify the assembly's entry point. Cette exception peut être levée dans les conditions suivantes :This exception can be thrown under the following conditions:

  • Le common language runtime ne parvient pas à localiser un point d’entrée d’application (généralement une Main méthode) dans un assembly exécutable.The common language runtime is unable to locate an application entry point (typically a Main method) in an executable assembly. Le point d’entrée de l’application doit être une méthode globale ou static qui n’a aucun paramètre ou un tableau de chaînes comme seul paramètre.The application entry point must be a global or static method that has either no parameters or a string array as its only parameter. Le point d’entrée peut retourner void ou retourner un Int32 code ou un UInt32 Code de sortie.The entry point can return void, or it can return an Int32 or UInt32 exit code. Un assembly d’application ne peut pas définir plus d’un point d’entrée.An application assembly cannot define more than one entry point.

  • L’appel à une fonction dans une DLL Windows ne peut pas être résolu, car la fonction est introuvable.The call to a function in a Windows DLL cannot be resolved because the function cannot be found. Dans l’exemple suivant, une EntryPointNotFoundException exception est levée, car User32.dll n’inclut pas de fonction nommée GetMyNumber .In the following example, an EntryPointNotFoundException exception is thrown because User32.dll does not include a function named GetMyNumber.

    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'.
    
    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'.
    
  • L’appel à une fonction dans une DLL Windows ne peut pas être résolu, car le nom utilisé dans l’appel de méthode ne correspond pas à un nom trouvé dans l’assembly.The call to a function in a Windows DLL cannot be resolved because the name used in the method call does not match a name found in the assembly. En général, cela se produit car le DllImportAttribute.ExactSpelling champ est implicitement ou explicitement défini sur true , la méthode appelée inclut un ou plusieurs paramètres de chaîne et a à la fois une version ANSI et une version Unicode, et le nom utilisé dans l’appel de méthode ne correspond pas au nom de cette version ANSI ou Unicode.Frequently, this occurs because the DllImportAttribute.ExactSpelling field is either implicitly or explicitly set to true, the called method includes one or more string parameters and has both an ANSI and a Unicode version, and the name used in the method call does not correspond to the name of this ANSI or Unicode version. L’exemple suivant fournit une illustration en tentant d’appeler la MessageBox fonction Windows dans User32.dll.The following example provides an illustration by attempting to call the Windows MessageBox function in User32.dll. Étant donné que la première définition de méthode spécifie CharSet.Unicode pour le marshaling de chaînes, le langage commun recherche la version à caractères larges de la fonction,, à la MessageBoxW place du nom utilisé dans l’appel de méthode MessageBox .Because the first method definition specifies CharSet.Unicode for string marshaling, the common language looks for the wide-character version of the function, MessageBoxW, instead of the name used in the method call, MessageBox. La deuxième définition de méthode corrige ce problème en appelant le MessageBoxW au lieu de la MessageBox fonction.The second method definition corrects this problem by calling the MessageBoxW instead of the MessageBox function.

    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);
          }
       }
    }
    
    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
    
  • Vous essayez d’appeler une fonction dans une bibliothèque de liens dynamiques par son nom simple plutôt que par son nom décoré.You are trying to call a function in a dynamic link library by its simple name rather than its decorated name. En règle générale, le compilateur C++ génère un nom décoré pour les fonctions DLL.Typically, the C++ compiler generates a decorated name for DLL functions. Par exemple, le code C++ suivant définit une fonction nommée Double dans une bibliothèque nommée TestDll.dll.For example, the following C++ code defines a function named Double in a library named TestDll.dll.

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

    Quand le code de l’exemple suivant tente d’appeler la fonction, une EntryPointNotFoundException exception est levée, car la Double fonction est introuvable.When the code in the following example tries to call the function, an EntryPointNotFoundException exception is thrown because the Double function cannot be found.

    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()
    
    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()
    

    Toutefois, si la fonction est appelée à l’aide de son nom décoré (dans ce cas, ?Double@@YAHH@Z ), l’appel de fonction se déroule correctement, comme le montre l’exemple suivant.However, if the function is called by using its decorated name (in this case, ?Double@@YAHH@Z), the function call succeeds, as the following example shows.

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

    Vous pouvez rechercher les noms décorés des fonctions exportées par une DLL à l’aide d’un utilitaire tel que Dumpbin.exe.You can find the decorated names of functions exported by a DLL by using a utility such as Dumpbin.exe.

  • Vous tentez d’appeler une méthode dans un assembly managé comme s’il s’agissait d’une bibliothèque de liens dynamiques non managée.You are attempting to call a method in a managed assembly as if it were an unmanaged dynamic link library. Pour voir cela en action, compilez l’exemple suivant dans un assembly nommé StringUtilities.dll.To see this in action, compile the following example to an assembly named 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
       Public Function SayGoodMorning(name As String) As String
          Return String.Format("A top of the morning to you, {0}!", name)
       End Function
    End Module
    

    Puis compilez et exécutez l’exemple suivant, qui tente d’appeler la StringUtilities.SayGoodMorning méthode dans la bibliothèque de liens dynamiques StringUtilities.dll comme s’il s’agissait de code non managé.Then compile and execute the following example, which attempts to call the StringUtilities.SayGoodMorning method in the StringUtilities.dll dynamic link library as if it were unmanaged code. Le résultat est une EntryPointNotFoundException exception.The result is an EntryPointNotFoundException exception.

    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()
    
    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()
    

    Pour éliminer l’exception, ajoutez une référence à l’assembly managé et accédez à la StringUtilities.SayGoodMorning méthode comme vous le feriez pour toute autre méthode dans du code managé, comme le montre l’exemple suivant.To eliminate the exception, add a reference to the managed assembly and access the StringUtilities.SayGoodMorning method just as you would access any other method in managed code, as the following example does.

    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!
    
    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!
    
  • Vous essayez d’appeler une méthode dans une DLL COM comme s’il s’agissait d’une DLL Windows.You are trying to call a method in a COM DLL as if it were a Windows DLL. Pour accéder à une DLL COM, sélectionnez l’option Ajouter une référence dans Visual Studio pour ajouter une référence au projet, puis sélectionnez la bibliothèque de types à partir de l’onglet com .To access a COM DLL, select the Add Reference option in Visual Studio to add a reference to the project, and then select the type library from the COM tab.

Pour obtenir la liste des valeurs initiales des propriétés d’une instance de EntryPointNotFoundException, consultez le EntryPointNotFoundException constructeurs.For a list of initial property values for an instance of EntryPointNotFoundException, see the EntryPointNotFoundException constructors.

Constructeurs

EntryPointNotFoundException()

Initialise une nouvelle instance de la classe EntryPointNotFoundException.Initializes a new instance of the EntryPointNotFoundException class.

EntryPointNotFoundException(SerializationInfo, StreamingContext)

Initialise une nouvelle instance de la classe EntryPointNotFoundException avec des données sérialisées.Initializes a new instance of the EntryPointNotFoundException class with serialized data.

EntryPointNotFoundException(String)

Initialise une nouvelle instance de la classe EntryPointNotFoundException avec un message d'erreur spécifié.Initializes a new instance of the EntryPointNotFoundException class with a specified error message.

EntryPointNotFoundException(String, Exception)

Initialise une nouvelle instance de la classe EntryPointNotFoundException avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception.Initializes a new instance of the EntryPointNotFoundException class with a specified error message and a reference to the inner exception that is the cause of this exception.

Propriétés

Data

Obtient une collection de paires clé/valeur qui fournissent des informations définies par l'utilisateur supplémentaires sur l'exception.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Hérité de Exception)
HelpLink

Obtient ou définit un lien vers le fichier d'aide associé à cette exception.Gets or sets a link to the help file associated with this exception.

(Hérité de Exception)
HResult

Obtient ou définit HRESULT, valeur numérique codée qui est assignée à une exception spécifique.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Hérité de Exception)
InnerException

Obtient l'instance Exception qui a provoqué l'exception actuelle.Gets the Exception instance that caused the current exception.

(Hérité de Exception)
Message

Obtient le message d’erreur pour cette exception.Gets the error message for this exception.

(Hérité de TypeLoadException)
Source

Obtient ou définit le nom de l'application ou de l'objet qui est à l'origine de l'erreur.Gets or sets the name of the application or the object that causes the error.

(Hérité de Exception)
StackTrace

Obtient une représentation sous forme de chaîne des frames immédiats sur la pile des appels.Gets a string representation of the immediate frames on the call stack.

(Hérité de Exception)
TargetSite

Obtient la méthode qui lève l'exception actuelle.Gets the method that throws the current exception.

(Hérité de Exception)
TypeName

Obtient le nom complet du type qui lève l’exception.Gets the fully qualified name of the type that causes the exception.

(Hérité de TypeLoadException)

Méthodes

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
GetBaseException()

En cas de substitution dans une classe dérivée, retourne la Exception qui est à l'origine d'une ou de plusieurs exceptions ultérieures.When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions.

(Hérité de Exception)
GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetObjectData(SerializationInfo, StreamingContext)

Définit l’objet SerializationInfo avec le nom de la classe, le nom de la méthode, l’ID de ressource et les informations d’exception complémentaires.Sets the SerializationInfo object with the class name, method name, resource ID, and additional exception information.

(Hérité de TypeLoadException)
GetType()

Obtient le type au moment de l'exécution de l'instance actuelle.Gets the runtime type of the current instance.

(Hérité de Exception)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
ToString()

Crée et retourne une chaîne représentant l'exception actuelle.Creates and returns a string representation of the current exception.

(Hérité de Exception)

Événements

SerializeObjectState

Se produit quand une exception est sérialisée pour créer un objet d'état d'exception qui contient des données sérialisées concernant l'exception.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Hérité de Exception)

S’applique à

Voir aussi