EntryPointNotFoundException Classe

Definição

Espaço de Nomes:: System

Assemblagem:: mscorlib.dll

Assemblagem:: netstandard.dll

Importante

Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.

A exceção é lançada quando uma tentativa de carregar uma classe falha devido à ausência de um método de entrada.

public ref class EntryPointNotFoundException : TypeLoadException

[System.Serializable]
public class EntryPointNotFoundException : TypeLoadException

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

public class EntryPointNotFoundException : TypeLoadException

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

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

type EntryPointNotFoundException = class
    inherit TypeLoadException

Public Class EntryPointNotFoundException
Inherits TypeLoadException

Herança: Object

Exception

SystemException

TypeLoadException
EntryPointNotFoundException

Atributos: SerializableAttribute ComVisibleAttribute

Observações

Uma EntryPointNotFoundException exceção é lançada quando o runtime da linguagem comum não consegue carregar um assembly porque não consegue identificar o ponto de entrada do assembly. Esta exceção pode ser lançada sob as seguintes condições:

O runtime da linguagem comum não consegue localizar um ponto de entrada de aplicação (tipicamente um Main método) num assembly executável. O ponto de entrada da aplicação deve ser um global ou static método que não tenha parâmetros ou um array de strings como único parâmetro. O ponto de entrada pode devolver void, ou pode devolver um Int32 código de saída.UInt32 Um assembly de aplicação não pode definir mais do que um ponto de entrada.

A chamada a uma função numa DLL do Windows não pode ser resolvida porque a função não pode ser encontrada. No exemplo seguinte, uma EntryPointNotFoundException exceção é lançada 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 a uma função numa DLL do Windows não pode ser resolvida porque o nome usado na chamada ao método não corresponde a um nome encontrado na assembleia. Frequentemente, isto ocorre porque o DllImportAttribute.ExactSpelling campo está implicitamente ou explicitamente definido como true, o método chamado inclui um ou mais parâmetros de cadeia e tem tanto uma versão ANSI como uma versão Unicode, e o nome usado na chamada ao método não corresponde ao nome desta versão ANSI ou Unicode. O exemplo seguinte fornece uma ilustração tentando chamar a função Windows MessageBox em User32.dll. Como a primeira definição de método especifica CharSet.Unicode o marshaling de strings, a linguagem comum procura a versão de caracteres largos da função, MessageBoxW, em vez do nome usado na chamada de método, MessageBox. A definição do segundo método corrige este problema chamando a MessageBoxW função em vez da MessageBox .

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

Estás a tentar chamar uma função numa biblioteca de links dinâmicos pelo seu nome simples em vez do nome decorado. Normalmente, o compilador C++ gera um nome decorado para funções DLL. Por exemplo, o código C++ seguinte define uma função nomeada Double numa biblioteca chamada TestDll.dll.

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

Quando o código no exemplo seguinte tenta chamar a função, é lançada uma EntryPointNotFoundException exceção 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 o seu nome decorado (neste caso, ?Double@@YAHH@Z), a chamada da função é bem-sucedida, como mostra o exemplo seguinte.

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

Pode encontrar os nomes decorados das funções exportadas por uma DLL usando uma utilidade como Dumpbin.exe.

Está a tentar chamar um método numa assembly gerida como se fosse uma biblioteca de links dinâmicos não gerida. Para ver isto em ação, compile o seguinte exemplo numa assembly chamada 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

Depois compila e executa o seguinte exemplo, que tenta chamar o StringUtilities.SayGoodMorning método na biblioteca de links dinâmicos StringUtilities.dll como se fosse código não gerido. O resultado é uma EntryPointNotFoundException exceção.

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 gerido e aceda ao StringUtilities.SayGoodMorning método tal como acede a qualquer outro método em código gerido, como faz o exemplo seguinte.

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!

Está a tentar chamar um método numa DLL COM como se fosse uma DLL do Windows. Para aceder a uma DLL COM, selecione a opção Add Reference no Visual Studio para adicionar uma referência ao projeto, e depois selecione a biblioteca de tipos no separador COM.

Para obter uma lista dos valores iniciais de propriedade de uma instância de EntryPointNotFoundException, consulte os construtores de EntryPointNotFoundException.

Construtores

Name	Description
EntryPointNotFoundException()	Inicializa uma nova instância da EntryPointNotFoundException classe.
EntryPointNotFoundException(SerializationInfo, StreamingContext)	Inicializa uma nova instância da EntryPointNotFoundException classe com dados serializados.
EntryPointNotFoundException(String, Exception)	Inicializa uma nova instância da EntryPointNotFoundException classe com uma mensagem de erro especificada e uma referência à exceção interna que é a causa dessa exceção.
EntryPointNotFoundException(String)	Inicializa uma nova instância da EntryPointNotFoundException classe com uma mensagem de erro especificada.

Propriedades

Name	Description
Data	Obtém uma coleção de pares chave/valor que fornecem informação adicional definida pelo utilizador sobre a exceção. (Herdado de Exception)
HelpLink	Obtém ou define um link para o ficheiro de ajuda associado a esta exceção. (Herdado de Exception)
HResult	Recebe ou define HRESULT, um valor numérico codificado atribuído a uma exceção específica. (Herdado de Exception)
InnerException	Obtém a Exception instância que causou a exceção atual. (Herdado de Exception)
Message	Recebe a mensagem de erro para esta exceção. (Herdado de TypeLoadException)
Source	Obtém ou define o nome do aplicativo ou o objeto que causa o erro. (Herdado de Exception)
StackTrace	Obtém uma representação string dos frames imediatos na stack de chamadas. (Herdado de Exception)
TargetSite	Obtém o método que lança a exceção atual. (Herdado de Exception)
TypeName	Recebe o nome totalmente qualificado do tipo que causa a exceção. (Herdado de TypeLoadException)

Métodos

Name	Description
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetBaseException()	Quando sobrescrito numa classe derivada, devolve o Exception que é a causa raiz de uma ou mais exceções subsequentes. (Herdado de Exception)
GetHashCode()	Serve como função de hash predefinida. (Herdado de Object)
GetObjectData(SerializationInfo, StreamingContext)	Define o SerializationInfo objeto com o nome da classe, nome do método, ID do recurso e informações adicionais de exceção. (Herdado de TypeLoadException)
GetType()	Obtém o tipo de execução da instância atual. (Herdado de Exception)
MemberwiseClone()	Cria uma cópia superficial do atual Object. (Herdado de Object)
ToString()	Cria e devolve uma representação string da exceção atual. (Herdado de Exception)

evento

Name	Description
SerializeObjectState	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

Ver também

Comentários

Esta página foi útil?