EntryPointNotFoundException Classe

Riferimento

Definizione

Spazio dei nomi:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Origine:: EntryPointNotFoundException.cs

Origine:: EntryPointNotFoundException.cs

Origine:: EntryPointNotFoundException.cs

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

L'eccezione generata quando il tentativo di caricare una classe non ha esito positivo per la mancanza di un metodo di inserimento.

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

Ereditarietà: Object

Exception

SystemException

TypeLoadException
EntryPointNotFoundException

Attributi: SerializableAttribute ComVisibleAttribute

Commenti

Quando Common Language Runtime non è in grado di caricare un assembly in quanto non riesce a identificare il punto di ingresso dell'assembly, viene generata un'eccezione EntryPointNotFoundException. Tale eccezione può essere generata nelle seguenti condizioni:

Common Language Runtime non è in grado di individuare un punto di ingresso dell'applicazione, in genere un metodo Main in un assembly eseguibile. Il punto di ingresso dell'applicazione deve essere un metodo static o globale che non dispone di parametri o che dispone come unico parametro di una matrice di stringhe. Il punto di ingresso può restituire void o un codice di uscita Int32 o UInt32. Un assembly dell'applicazione non è in grado di definire più di un punto di ingresso.

La chiamata a una funzione in una DLL di Windows non può essere risolta in quanto la funzione non è disponibile. Nell'esempio seguente viene generata un'eccezione EntryPointNotFoundException perché User32.dll non comprende una funzione denominata 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'.

La chiamata a una funzione in una DLL di Windows non può essere risolta in quanto il nome utilizzato nella chiamata al metodo non corrisponde al nome trovato nell'assembly. Spesso questo si verifica perché il campo DllImportAttribute.ExactSpelling è impostato in modo implicito o esplicito su true, il metodo chiamato include uno o più parametri di stringa e contiene sia una versione ANSI che Unicode e il nome utilizzato nella chiamata al metodo non corrisponde al nome di questa versione Unicode o ANSI. Nell'esempio seguente viene illustrato questo concetto mediante il tentativo di chiamare la funzione MessageBox di Windows in User32.dll. Poiché la prima definizione del metodo specifica CharSet.Unicode per il marshalling della stringa, Common Language Runtime cerca la versione a caratteri wide della funzione, MessageBoxW, anziché il nome utilizzato nella chiamata al metodo, MessageBox. La seconda definizione del metodo risolve il problema chiamando MessageBoxW anziché la funzione 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

Si sta tentando di chiamare una funzione in una DLL mediante il relativo nome semplice anziché quello decorato. In genere, il compilatore C++ genera un nome decorato per le funzioni DLL. Ad esempio, il seguente codice C++ definisce una funzione denominata Double in una libreria denominata TestDll.dll.

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

Quando il codice dell'esempio seguente tenta di chiamare la funzione, viene generata un'eccezione EntryPointNotFoundException perché la funzione Double non è disponibile.

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

Tuttavia, se la funzione viene chiamata utilizzando il relativo nome decorato, in questo caso, ?Double@@YAHH@Z, la chiamata alla funzione ha esito positivo, come illustrato nell'esempio seguente.

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

È possibile trovare i nomi decorati delle funzioni esportate da una DLL mediante un'utilità come Dumpbin.exe.

Si sta tentando di chiamare un metodo in un assembly gestito come se fosse una DLL non gestita. Per una verifica pratica, compilare l'esempio seguente in un assembly denominato 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

Compilare quindi ed eseguire l'esempio seguente, in cui viene effettuato un tentativo di chiamare il metodo StringUtilities.SayGoodMorning nella DLL StringUtilities.dll, come se si trattasse di codice non gestito. Il risultato è un'eccezione 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()

Per eliminare l'eccezione, aggiungere un riferimento all'assembly gestito e accedere al metodo StringUtilities.SayGoodMorning come se si trattasse di qualsiasi altro metodo nel codice gestito, come viene fatto nell'esempio seguente.

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!

Si sta tentando di chiamare un metodo in una DLL COM come se si trattasse di una DLL di Windows. Per accedere a una DLL COM, selezionare l'opzione Aggiungi riferimento in Visual Studio per aggiungere un riferimento al progetto e quindi selezionare la libreria dei tipi dalla scheda COM .

Per un elenco di valori di proprietà iniziali per un'istanza di EntryPointNotFoundException, vedere il EntryPointNotFoundException costruttori.

Costruttori

EntryPointNotFoundException()	Inizializza una nuova istanza della classe EntryPointNotFoundException.
EntryPointNotFoundException(SerializationInfo, StreamingContext)	Obsoleti. Inizializza una nuova istanza della classe EntryPointNotFoundException con dati serializzati.
EntryPointNotFoundException(String)	Inizializza una nuova istanza della classe EntryPointNotFoundException con un messaggio di errore specificato.
EntryPointNotFoundException(String, Exception)	Inizializza una nuova istanza della classe EntryPointNotFoundException con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente.

Proprietà

Data	Ottiene una raccolta di coppie chiave/valore che forniscono informazioni definite dall'utente aggiuntive sull'eccezione. (Ereditato da Exception)
HelpLink	Ottiene o imposta un collegamento al file della Guida associato all'eccezione. (Ereditato da Exception)
HResult	Ottiene o imposta HRESULT, un valore numerico codificato che viene assegnato a un'eccezione specifica. (Ereditato da Exception)
InnerException	Ottiene l'istanza di Exception che ha causato l'eccezione corrente. (Ereditato da Exception)
Message	Ottiene il messaggio di errore per l'eccezione. (Ereditato da TypeLoadException)
Source	Ottiene o imposta il nome dell'oggetto o dell'applicazione che ha generato l'errore. (Ereditato da Exception)
StackTrace	Ottiene una rappresentazione di stringa dei frame immediati nello stack di chiamate. (Ereditato da Exception)
TargetSite	Ottiene il metodo che genera l'eccezione corrente. (Ereditato da Exception)
TypeName	Ottiene il nome completo del tipo che provoca l'eccezione. (Ereditato da TypeLoadException)

Metodi

Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetBaseException()	Quando ne viene eseguito l'override in una classe derivata, restituisce l'Exception che è la causa radice di una o più eccezioni successive. (Ereditato da Exception)
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetObjectData(SerializationInfo, StreamingContext)	Obsoleti. Imposta l'oggetto SerializationInfo con il nome della classe, il nome del metodo, l'ID risorsa e altre informazioni sull'eccezione. (Ereditato da TypeLoadException)
GetType()	Ottiene il tipo di runtime dell'istanza corrente. (Ereditato da Exception)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
ToString()	Crea e restituisce una rappresentazione di stringa dell'eccezione corrente. (Ereditato da Exception)

Eventi

SerializeObjectState

Obsoleti.

Si verifica quando un'eccezione viene serializzata per creare un oggetto di stato eccezione contenente i dati serializzati relativi all'eccezione.

(Ereditato da Exception)

Si applica a

Condividi tramite