EntryPointNotFoundException Classe

Definizione

L'eccezione generata quando il tentativo di caricare una classe non ha esito positivo per la mancanza di un metodo di inserimento.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
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class EntryPointNotFoundException : TypeLoadException
type EntryPointNotFoundException = class
    inherit TypeLoadException
Public Class EntryPointNotFoundException
Inherits TypeLoadException
Ereditarietà
EntryPointNotFoundException
Attributi

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.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. Tale eccezione può essere generata nelle seguenti condizioni:This exception can be thrown under the following conditions:

  • Common Language Runtime non è in grado di individuare un punto di ingresso dell'applicazione, in genere un metodo Main in un assembly eseguibile.The common language runtime is unable to locate an application entry point (typically a Main method) in an executable assembly. 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.The application entry point must be a global or static method that has either no parameters or a string array as its only parameter. Il punto di ingresso può restituire void o un codice di uscita Int32 o UInt32.The entry point can return void, or it can return an Int32 or UInt32 exit code. Un assembly dell'applicazione non è in grado di definire più di un punto di ingresso.An application assembly cannot define more than one entry point.

  • La chiamata a una funzione in una DLL di Windows non può essere risolta in quanto la funzione non è disponibile.The call to a function in a Windows DLL cannot be resolved because the function cannot be found. Nell'esempio seguente viene generata un'eccezione EntryPointNotFoundException perché User32.dll non comprende una funzione denominata 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'.
    
  • 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.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. 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.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. Nell'esempio seguente viene illustrato questo concetto mediante il tentativo di chiamare la funzione MessageBox di Windows in User32.dll.The following example provides an illustration by attempting to call the Windows MessageBox function 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.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 seconda definizione del metodo risolve il problema chiamando MessageBoxW anziché la funzione MessageBox.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
    
  • Si sta tentando di chiamare una funzione in una DLL mediante il relativo nome semplice anziché quello decorato.You are trying to call a function in a dynamic link library by its simple name rather than its decorated name. In genere, il compilatore C++ genera un nome decorato per le funzioni DLL.Typically, the C++ compiler generates a decorated name for DLL functions. Ad esempio, il seguente codice C++ definisce una funzione denominata Double in una libreria denominata 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;
    }
    

    Quando il codice dell'esempio seguente tenta di chiamare la funzione, viene generata un'eccezione EntryPointNotFoundException perché la funzione Double non è disponibile.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()
    

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

    È possibile trovare i nomi decorati delle funzioni esportate da una DLL mediante un'utilità come Dumpbin.exe.You can find the decorated names of functions exported by a DLL by using a utility such as Dumpbin.exe.

  • Si sta tentando di chiamare un metodo in un assembly gestito come se fosse una DLL non gestita.You are attempting to call a method in a managed assembly as if it were an unmanaged dynamic link library. Per una verifica pratica, compilare l'esempio seguente in un assembly denominato 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
    

    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.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. Il risultato è un'eccezione EntryPointNotFoundException.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()
    

    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.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!
    
  • Si sta tentando di chiamare un metodo in una DLL COM come se si trattasse di una DLL di Windows.You are trying to call a method in a COM DLL as if it were a Windows DLL. Per accedere a una DLL COM, selezionare l'opzione Aggiungi riferimento in Visual Studio per aggiungere un riferimento al progetto, quindi selezionare la libreria dei tipi dalla scheda 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.

Per un elenco di valori di proprietà iniziali per un'istanza di EntryPointNotFoundException, vedere il EntryPointNotFoundException costruttori.For a list of initial property values for an instance of EntryPointNotFoundException, see the EntryPointNotFoundException constructors.

Costruttori

EntryPointNotFoundException()

Inizializza una nuova istanza della classe EntryPointNotFoundException.Initializes a new instance of the EntryPointNotFoundException class.

EntryPointNotFoundException(SerializationInfo, StreamingContext)

Inizializza una nuova istanza della classe EntryPointNotFoundException con dati serializzati.Initializes a new instance of the EntryPointNotFoundException class with serialized data.

EntryPointNotFoundException(String)

Inizializza una nuova istanza della classe EntryPointNotFoundException con un messaggio di errore specificato.Initializes a new instance of the EntryPointNotFoundException class with a specified error message.

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

Proprietà

Data

Ottiene una raccolta di coppie chiave-valore che fornisce informazioni aggiuntive definite dall'utente relative all'eccezione.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Ereditato da Exception)
HelpLink

Ottiene o imposta un collegamento al file della Guida associato all'eccezione.Gets or sets a link to the help file associated with this exception.

(Ereditato da Exception)
HResult

Ottiene o imposta HRESULT, un valore numerico codificato che viene assegnato a un'eccezione specifica.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Ereditato da Exception)
InnerException

Ottiene l'istanza di Exception che ha causato l'eccezione corrente.Gets the Exception instance that caused the current exception.

(Ereditato da Exception)
Message

Ottiene il messaggio di errore per questa eccezione.Gets the error message for this exception.

(Ereditato da TypeLoadException)
Source

Ottiene o imposta il nome dell'oggetto o dell'applicazione che ha generato l'errore.Gets or sets the name of the application or the object that causes the error.

(Ereditato da Exception)
StackTrace

Ottiene una rappresentazione di stringa dei frame immediati nello stack di chiamate.Gets a string representation of the immediate frames on the call stack.

(Ereditato da Exception)
TargetSite

Ottiene il metodo che genera l'eccezione corrente.Gets the method that throws the current exception.

(Ereditato da Exception)
TypeName

Ottiene il nome completo del tipo che provoca l'eccezione.Gets the fully qualified name of the type that causes the exception.

(Ereditato da TypeLoadException)

Metodi

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
GetBaseException()

Se utilizzato come metodo di override in una classe derivata, restituisce l'Exception che è la causa radice di una o più eccezioni successive.When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions.

(Ereditato da Exception)
GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetObjectData(SerializationInfo, StreamingContext)

Imposta l'oggetto SerializationInfo con il nome della classe, il nome del metodo, l'ID risorsa e altre informazioni sull'eccezione.Sets the SerializationInfo object with the class name, method name, resource ID, and additional exception information.

(Ereditato da TypeLoadException)
GetType()

Ottiene il tipo di runtime dell'istanza corrente.Gets the runtime type of the current instance.

(Ereditato da Exception)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
ToString()

Crea e restituisce una rappresentazione di stringa dell'eccezione corrente.Creates and returns a string representation of the current exception.

(Ereditato da Exception)

Eventi

SerializeObjectState

Si verifica quando un'eccezione viene serializzata per creare un oggetto di stato eccezione contenente i dati serializzati relativi all'eccezione.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Ereditato da Exception)

Si applica a

Vedi anche