Compartilhar via


EntryPointNotFoundException Classe

Definição

A exceção gerada quando ocorre falha ao tentar carregar uma classe devido a ausência de um método de entrada.

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
Herança
EntryPointNotFoundException
Atributos

Comentários

Uma EntryPointNotFoundException exceção é gerada quando o Common Language Runtime não consegue carregar um assembly porque não consegue identificar o ponto de entrada do assembly. Essa exceção pode ser gerada sob as seguintes condições:

  • O Common Language Runtime não consegue localizar um ponto de entrada do aplicativo (normalmente um Main método) em um assembly executável. O ponto de entrada do aplicativo deve ser um método ou static global que não tenha parâmetros ou uma matriz de cadeia de caracteres como seu único parâmetro. O ponto de entrada pode retornar voidou pode retornar um Int32 código de saída ou UInt32 . Um assembly de aplicativo não pode definir mais de um ponto de entrada.

  • A chamada para uma função em uma DLL do Windows não pode ser resolvida porque a função não pode ser encontrada. No exemplo a seguir, uma exceção EntryPointNotFoundException é gerada porque User32.dll não inclui uma função chamada 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'.
    
    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'.
    
  • A chamada para uma função em uma DLL do Windows não pode ser resolvida porque o nome usado na chamada de método não corresponde a um nome encontrado no assembly. Frequentemente, isso ocorre porque o DllImportAttribute.ExactSpelling campo é definido implicitamente ou explicitamente como true, o método chamado inclui um ou mais parâmetros de cadeia de caracteres e tem uma versão ANSI e Unicode, e o nome usado na chamada de método não corresponde ao nome dessa versão ANSI ou Unicode. O exemplo a seguir fornece uma ilustração tentando chamar a função do Windows MessageBox em User32.dll. Como a primeira definição de método especifica para marshaling de cadeia de caracteres CharSet.Unicode , a linguagem comum procura a versão de caractere largo da função, MessageBoxW, em vez do nome usado na chamada de método, MessageBox. A segunda definição de método corrige esse problema chamando o MessageBoxW em vez da MessageBox função .

    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
    
  • Você está tentando chamar uma função em uma biblioteca de vínculo dinâmico por seu nome simples em vez de seu nome decorado. Normalmente, o compilador C++ gera um nome decorado para funções DLL. Por exemplo, o código C++ a seguir define uma função chamada Double em uma biblioteca chamada TestDll.dll.

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

    Quando o código no exemplo a seguir tenta chamar a função, uma exceção EntryPointNotFoundException é gerada porque a Double função não pode ser encontrada.

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

    No entanto, se a função for chamada usando seu nome decorado (nesse caso, ?Double@@YAHH@Z), a chamada de função terá êxito, como mostra o exemplo a seguir.

    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
    

    Você pode encontrar os nomes decorados de funções exportadas por uma DLL usando um utilitário como Dumpbin.exe.

  • Você está tentando chamar um método em um assembly gerenciado como se fosse uma biblioteca de link dinâmico não gerenciada. Para ver isso em ação, compile o exemplo a seguir em um assembly chamado 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
    

    Em seguida, compile e execute o exemplo a seguir, que tenta chamar o StringUtilities.SayGoodMorning método na biblioteca de link dinâmico StringUtilities.dll como se fosse um código não gerenciado. O resultado é uma exceção EntryPointNotFoundException .

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

    Para eliminar a exceção, adicione uma referência ao assembly gerenciado e acesse o StringUtilities.SayGoodMorning método da mesma forma que você acessaria qualquer outro método no código gerenciado, como faz o exemplo a seguir.

    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!
    
  • Você está tentando chamar um método em uma DLL COM como se fosse uma DLL do Windows. Para acessar uma DLL COM, selecione a opção Adicionar Referência no Visual Studio para adicionar uma referência ao projeto e selecione a biblioteca de tipos na guia COM .

Para obter uma lista de valores de propriedade inicial para uma instância do EntryPointNotFoundException, consulte o EntryPointNotFoundException construtores.

Construtores

EntryPointNotFoundException()

Inicializa uma nova instância da classe EntryPointNotFoundException.

EntryPointNotFoundException(SerializationInfo, StreamingContext)
Obsoleto.

Inicializa uma nova instância da classe EntryPointNotFoundException com dados serializados.

EntryPointNotFoundException(String)

Inicializa uma nova instância da classe EntryPointNotFoundException com uma mensagem de erro especificada.

EntryPointNotFoundException(String, Exception)

Inicializa uma nova instância da classe EntryPointNotFoundException com uma mensagem de erro especificada e uma referência à exceção interna que é a causa da exceção.

Propriedades

Data

Obtém uma coleção de pares de chave/valor que fornecem informações definidas pelo usuário adicionais sobre a exceção.

(Herdado de Exception)
HelpLink

Obtém ou define um link para o arquivo de ajuda associado a essa exceção.

(Herdado de Exception)
HResult

Obtém ou define HRESULT, um valor numérico codificado que é atribuído a uma exceção específica.

(Herdado de Exception)
InnerException

Obtém a instância Exception que causou a exceção atual.

(Herdado de Exception)
Message

Obtém a mensagem de erro desta exceção.

(Herdado de TypeLoadException)
Source

Obtém ou define o nome do aplicativo ou objeto que causa o erro.

(Herdado de Exception)
StackTrace

Obtém uma representação de cadeia de caracteres de quadros imediatos na pilha de chamadas.

(Herdado de Exception)
TargetSite

Obtém o método que gerou a exceção atual.

(Herdado de Exception)
TypeName

Obtém o nome totalmente qualificado do tipo que causa a exceção.

(Herdado de TypeLoadException)

Métodos

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.

(Herdado de Object)
GetBaseException()

Quando substituído em uma classe derivada, retorna a Exception que é a causa raiz de uma ou mais exceções subsequentes.

(Herdado de Exception)
GetHashCode()

Serve como a função de hash padrão.

(Herdado de Object)
GetObjectData(SerializationInfo, StreamingContext)
Obsoleto.

Define o objeto SerializationInfo com o nome de classe, do método, ID de recurso e informações adicionais de exceção.

(Herdado de TypeLoadException)
GetType()

Obtém o tipo de runtime da instância atual.

(Herdado de Exception)
MemberwiseClone()

Cria uma cópia superficial do Object atual.

(Herdado de Object)
ToString()

Cria e retorna uma representação de cadeia de caracteres da exceção atual.

(Herdado de Exception)

Eventos

SerializeObjectState
Obsoleto.

Ocorre quando uma exceção é serializada para criar um objeto de estado de exceção que contém dados serializados sobre a exceção.

(Herdado de Exception)

Aplica-se a

Confira também