C# Signature:

[DllImport("kernel32", CharSet=CharSet.Ansi, ExactSpelling=true, SetLastError=true)]
static extern IntPtr GetProcAddress(IntPtr hModule, string procName);

VB.NET Signature:

<DllImport("kernel32.dll", SetLastError:=True, CharSet:=CharSet.Ansi, ExactSpelling:=True)> _
Private Function GetProcAddress(ByVal hModule As IntPtr, ByVal procName As String) As UIntPtr
End Function

VB Signature:

Private Declare Function GetProcAddress Lib "kernel32" (ByVal hModule As Integer, ByVal lpProcName As String) As Integer

C++ Signature:

[DllImport("KERNEL32.DLL", CharSet=CharSet::Ansi, EntryPoint="GetProcAddress", ExactSpelling=true)]
static IntPtr GetProcAddress(IntPtr hModule, String^ lpProcName);

Boo Signature:

[DllImport("kernel32.dll", CharSet : CharSet.Ansi, ExactSpelling : true)]
static def GetProcAddress(hModule as IntPtr, procName as string) as IntPtr:
     pass

User-Defined Types:

None.

Notes:

GetProcAddress only comes in an ANSI flavor, hence we help the runtime by telling it to always use ANSI when marshalling the string parameter. We also prevent the runtime looking for a non-existent GetProcAddressA, because the default for C# is to set ExactSpelling to false.

Tips & Tricks:

This API becomes a lot more interesting in .NET v2.0 because the System.Runtime.InteropServices.Marshal class gains a new API called GetDelegateForFunctionPointer(). This means that you will be able to write code like this:

internal static class UnsafeNativeMethods {
   [DllImport("kernel32", CharSet=CharSet.Ansi, ExactSpelling=true, SetLastError=true)]
   internal static extern IntPtr GetProcAddress(IntPtr hModule, string procName );
}

internal delegate int DllRegisterServerInvoker();

// code snippet in a method somewhere, error checking omitted
IntPtr fptr = UnsafeNativeMethods.GetProcAddress( hModule, "DllRegisterServer" );
DllRegisterServerInvoker drs = (DllRegisterServerInvoker) Marshal.GetDelegateForFunctionPointer( fptr, typeof(DllRegisterServerInvoker) );
drs(); // call via a function pointer

Some DLLs only export by ordinal. Because you can't express this mode of GetProcAddress to the marshaller, one possibility is to import the function a second time with another name, such as:

[DllImport("kernel32", SetLastError = true, EntryPoint = "GetProcAddress")]
static extern IntPtr GetProcAddressOrdinal(IntPtr hModule, IntPtr procName);

Sample Code:

for load function "Test" from DLL "MyDLL.dll" we do this codes:

static HMODULE hDLL;
typedef HRESULT (STDAPICALLTYPE * LPFNTEST) (void);
LPFNTEST _pfnTest;

hDLL = LoadLibrary("MyDLL.dll");
_pfnTest = (LPFNTEST)::GetProcAddress(hDLL, "Test");

Alternative Managed API:

Do you know one? Please contribute it!

Please edit this page!

Do you have...

• helpful tips or sample code to share for using this API in managed code?
• corrections to the existing content?
• variations of the signature you want to share?
• additional languages you want to include?

Select "Edit This Page" on the right hand toolbar and edit it! Or add new pages containing supporting types needed for this API (structures, delegates, and more).