GL_POINT_BIT = 0x00000002,

        GL_POINTS = 0x0000,

        GL_POINT_TOKEN = 0x0701,

        GL_POINT_SMOOTH = 0x0B10,

        GL_POINT_SIZE = 0x0B11,

        GL_POINT_SIZE_RANGE = 0x0B12,

        GL_POINT_SIZE_GRANULARITY = 0x0B13,

        GL_POINT_SMOOTH_HINT = 0x0C51,

        GL_FEEDBACK_BUFFER_POINTER = 0x0DF0,

        GL_SELECTION_BUFFER_POINTER = 0x0DF3,

        GL_POINT = 0x1B00,

        GL_POLYGON_OFFSET_POINT = 0x2A01,

        GL_VERTEX_ARRAY_POINTER = 0x808E,

        GL_NORMAL_ARRAY_POINTER = 0x808F,

        GL_COLOR_ARRAY_POINTER = 0x8090,

        GL_INDEX_ARRAY_POINTER = 0x8091,

        GL_TEXTURE_COORD_ARRAY_POINTER = 0x8092,

        GL_EDGE_FLAG_ARRAY_POINTER = 0x8093,

        GL_VERTEX_ARRAY_POINTER_EXT = 0x808E,

        GL_NORMAL_ARRAY_POINTER_EXT = 0x808F,

        GL_COLOR_ARRAY_POINTER_EXT = 0x8090,

        GL_INDEX_ARRAY_POINTER_EXT = 0x8091,

        GL_TEXTURE_COORD_ARRAY_POINTER_EXT = 0x8092,

        GL_EDGE_FLAG_ARRAY_POINTER_EXT = 0x8093,

        GLU_POINT = 100010,

    public static extern void glColorPointer(int size, uint type, int stride, int[] pointer);

    public static extern void glEdgeFlagPointer(int stride, int[] pointer);

    public static extern void glEvalPoint1(int i);

    public static extern void glEvalPoint2(int i, int j);

    public static extern void glGetPointerv(uint pname, int[] params_notkeyword);

    public static extern void glIndexPointer(uint type, int stride, int[] pointer);

    public static extern void glInterleavedArrays(uint format, int stride, int[] pointer);

    public static extern void glMap1d(uint target, double u1, double u2, int stride, int order, double[] points);

    public static extern void glMap1f(uint target, float u1, float u2, int stride, int order, float[] points);

    public static extern void glMap2d(uint target, double u1, double u2, int ustride, int uorder, double v1, double v2, int vstride, int vorder, double[] points);

    public static extern void glMap2f(uint target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float[] points);

    public static extern void glNormalPointer(uint type, int stride, float[] pointer);

    public static extern void glPointSize(float size);

    public static extern void glTexCoordPointer(int size, uint type, int stride, float[] pointer);

    public static extern void glVertexPointer(int size, uint type, int stride, float[] pointer);

[DllImport("opengl32", EntryPoint = "wglUseFontOutlines", CallingConvention=CallingConvention.Winapi)]

    public POINTFLOAT  gmfptGlyphOrigin;

public struct POINTFLOAT

                    System.Drawing.GraphicsUnit.Point,

    public IntPtr ExceptionPointers;

    public int ClientPointers;

    info.ClientPointers = 1;

    info.ExceptionPointers = Marshal.GetExceptionPointers();

      [DllImport("iphlpapi.dll", EntryPoint = "AddIPAddress", SetLastError = true)]

    Public Pointer As IntPtr

    <DllImport("kernel32.dll", EntryPoint:="CreateEventA", CharSet:=CharSet.Unicode)>

        IF_TYPE_PROP_POINT2POINT_SERIAL = 22,  // proprietary serial

<DllImport("iphlpapi.dll", EntryPoint:="GetAdaptersInfo", CharSet:=CharSet.Ansi)> _

GetAdaptersInfo returns a pointer to an IP_ADAPTER_INFO linked list.

    /// <param name="pIfTable">A pointer to a buffer that receives the interface table as a MIB_IFTABLE structure</param>

    /// On input, specifies the size in bytes of the buffer pointed to by the pIfTable parameter.

[DllImport(S"IPHLPAPI.DLL", EntryPoint=S"GetIpAddrTable", SetLastError=true, CharSet=CharSet::Unicode, ExactSpelling=true)]

[DllImport("iphlpapi.dll", EntryPoint="GetIpNetTable")]

            // Increment the memory pointer by the size of the int.

        ' Increment the memory pointer by the size of the int.

        /// The buffer pointed to by the pIpNetTable parameter is not large enough.

        /// The required size is returned in the DWORD variable pointed to

        /// to the memory pointed to by the pdwSize parameter.

        /// <param name="pIpNetTable">A pointer to a buffer that receives the

        /// <param name="pdwSize">On input, specifies the size of the buffer pointed to

        [DllImport("Iphlpapi.dll", EntryPoint="GetIpNetTable")]

    [DllImport("Iphlpapi.dll", EntryPoint = "PfAddFiltersToInterface")]

    /// <param name="cInFilters">[in] Specifies the number of input filter descriptions pointed to by the pfiltIn parameter.</param>

    /// <param name="pfiltIn">[in] Pointer to an array of filter descriptions to use as input filters.</param>

    /// <param name="cOutFilters">[in] Specifies the number of output filter descriptions pointed to by the pfiltOut parameter.</param>

    /// <param name="pFiltOut">[in] Pointer to an array of filter descriptions to use as output filters.</param>

    /// <param name="pfHandle">[out] Pointer to a buffer that receives an array of filter handles. If the caller does not require the filter handles, the caller may set this parameter to NULL.</param>

    [DllImport("iphlpapi.dll", EntryPoint = "PfBindInterfaceToIPAddress")]

    /// <param name="IPAddress">[in] Pointer to an array of bytes that specifies the IP address for the interface.</param>

    [DllImport("Iphlpapi.dll", EntryPoint = "PfCreateInterface")]

    /// <param name="ppInterface">[out] Pointer to a pointer that, on successful return, points to an interface handle to use with subsequent function calls.</param>

    [DllImport("iphlpapi.dll", EntryPoint = "PfDeleteInterface")]

    [DllImport("iphlpapi.dll", EntryPoint = "PfRemoveFiltersFromInterface")]

    /// <param name="cInFilters">[in] Specifies the number of input filter descriptions pointed to by the pfiltIn parameter.</param>

    /// <param name="pfiltIn">[in] Pointer to an array of filter descriptions to use as input filters.</param>

    /// <param name="cOutFilters">[in] Specifies the number of output filters descriptions pointed to by the pfiltOut parameter.</param>

    /// <param name="pfiltOut">[in] Pointer to an array of filter descriptions to use as output filters.</param>

    [DllImport("iphlpapi.dll", EntryPoint = "PfTestPacket")]

    /// <param name="pbPacket">[in] Pointer to a network packet to test with the specified interface (or interfaces).</param>

    /// <param name="ppAction">[out] Pointer to a variable of type PFFORWARD_ACTION. This variable receives the action that would have been taken given the specified interface(s) and packet.</param>

    Public Pointer As IntPtr

[DllImport("CRYPT32.DLL", EntryPoint = "CertAddEncodedCertificateToStore", CharSet = CharSet.Auto, SetLastError = true)]

[DllImport("CRYPT32.DLL", EntryPoint="CertCloseStore", CharSet=CharSet.Auto, SetLastError=true)]

     [DllImport("Crypt32.DLL", EntryPoint="CertCreateCertificateContext",

This function actually returns a CTL_CONTEXT pointer (please see CTL_CONTEXT on this site)

[DllImport("CRYPT32.DLL", EntryPoint="CertEnumCertificatesInStore", CharSet=CharSet.Auto, SetLastError=true)]

     <DllImport("crypt32.dll", EntryPoint:="CertEnumCertificatesInStore", CharSet:=CharSet.Auto, SetLastError:=True)> _

[DllImport("crypt32.dll", EntryPoint = "CertGetNameString", CharSet = CharSet.Auto, SetLastError = true)]

    [DllImport("crypt32.dll", SetLastError = true, EntryPoint = "CertNameToStr")]

[DllImport("CRYPT32.DLL", EntryPoint="CertOpenStore", CharSet=CharSet.Auto, SetLastError=true)]

[DllImport("CRYPT32.DLL", EntryPoint="CertOpenStore", CharSet=CharSet.Auto, SetLastError=true)]

    [DllImport("CRYPT32.DLL", EntryPoint = "CryptQueryObject", CharSet = CharSet.Auto, SetLastError = true)]

        rgpbToBeSigned,       // Pointer to signed BLOB.

Unsafe Code refers to C# code with Pointers in it.

"The use of pointers is rarely required in C#, but there are some situations that require them. Using an 'unsafe' context to allow pointers is warranted [... for use of] Advanced COM or Platform Invoke scenarios that involve structures with pointers in them" e.g.

"You cannot return the same exact pointer from a native function that you took as a parameter. If a native function returns the pointer that has been marshaled to it by PInvoke[c or c++ or DllImport in c#], memory corruption and exceptions may ensue." http://msdn.microsoft.com/en-us/library/ms235282.aspx

    // TODO: Test - what's an out uint[] during interop? This probably isn't quite right, but provides a starting point:

    [DllImport("kernel32.dll", EntryPoint = "ReadConsoleInputW", CharSet = CharSet.Unicode)]

     EntryPoint:="CreateEventA")> _

        byte* p = (byte*)hMVF.ToPointer() + iViewDelta;

        byte* p = (byte*)hMVF.ToPointer() + iViewDelta;

        byte* p = (byte*)hMVF.ToPointer() + iViewDelta;

        byte* p = (byte*)hMVF.ToPointer() + iViewDelta;

        byte* p = (byte*)hMVF.ToPointer() + iViewDelta;

        byte* p = (byte*)hMVF.ToPointer() + iViewDelta;

        byte* p = (byte*)hMVF.ToPointer() + iViewDelta;

        byte* p = (byte*)hMVF.ToPointer() + iViewDelta;

        /// Main entry point for the application.

    [DllImport("kernel32.dll", EntryPoint = "CreateFile", SetLastError = true)]

    [DllImport("kernel32.dll", EntryPoint = "PeekNamedPipe", SetLastError = true)]

The key is to use Marshal.GetFunctionPointerForDelegate to get an IntPtr to the method that will serve as the thread proc.

DeleteVolumeMountPoint(@"Y:\");

static extern bool DeleteVolumeMountPoint(string lpszVolumeMountPoint);

DeleteVolumeMountPoint(DriveLetter+":\\");

     FsctlQueryRetrievalPointers = (EFileDevice.FileSystem << 16) | (14 << 2) | EMethod.Neither | (0 << 14),

     FsctlGetRetrievalPointers = (EFileDevice.FileSystem << 16) | (28 << 2) | EMethod.Neither | (0 << 14),

     FsctlSetReparsePoint = (EFileDevice.FileSystem << 16) | (41 << 2) | EMethod.Buffered | (0 << 14),

     FsctlGetReparsePoint = (EFileDevice.FileSystem << 16) | (42 << 2) | EMethod.Buffered | (0 << 14),

     FsctlDeleteReparsePoint = (EFileDevice.FileSystem << 16) | (43 << 2) | EMethod.Buffered | (0 << 14),

<DllImport("kernel32.dll", CharSet:=CharSet.Unicode, EntryPoint:="EnumResourceNamesW", SetLastError:=True)> _

<DllImport("kernel32.dll", CharSet:=CharSet.Unicode, EntryPoint:="EnumResourceNamesW", SetLastError:=True)> _

    <DllImport("kernel32.dll", CharSet:=CharSet.Unicode, EntryPoint:="EnumResourceNamesW", SetLastError:=True)> _

    <DllImport("kernel32.dll", CharSet:=CharSet.Unicode, EntryPoint:="EnumResourceNamesW", SetLastError:=True)> _

    [DllImport("kernel32.dll", EntryPoint = "EnumResourceNamesW", CharSet = CharSet.Unicode, SetLastError = true)]

    [DllImport("kernel32.dll", EntryPoint = "EnumResourceNamesW", CharSet = CharSet.Unicode, SetLastError = true)]

    /// The main entry point for the application.

<DllImport("kernel32.dll", EntryPoint:="ExpandEnvironmentStringsW", SetLastError:=true, CharSet:=CharSet.Unicode)> _

  [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true, EntryPoint="CreateFileW")]

<DllImport("Kernel32.dll", EntryPoint:="FormatMessageW", SetLastError:=True, CharSet:=CharSet.Unicode, CallingConvention:=CallingConvention.StdCall)> _

<DllImport("Kernel32.dll", EntryPoint:="FormatMessageW", SetLastError:=True, CharSet:=CharSet.Unicode, CallingConvention:=CallingConvention.StdCall)> _

<DllImport("Kernel32.dll", EntryPoint:="FormatMessageW", SetLastError:=True, CharSet:=CharSet.Unicode, CallingConvention:=CallingConvention.StdCall)> _

<DllImport("Kernel32.dll", EntryPoint:="FormatMessageW", SetLastError:=True, CharSet:=CharSet.Unicode, CallingConvention:=CallingConvention.StdCall)> _

<DllImport("Kernel32.dll", EntryPoint:="FormatMessageW", SetLastError:=True, CharSet:=CharSet.Unicode, CallingConvention:=CallingConvention.StdCall)> _

<DllImport("Kernel32.dll", EntryPoint:="FormatMessageW", SetLastError:=True, CharSet:=CharSet.Unicode, CallingConvention:=CallingConvention.StdCall)> _

    <System.Runtime.InteropServices.DllImport("Kernel32.dll", EntryPoint:="FormatMessageW", SetLastError:=True, CharSet:=System.Runtime.InteropServices.CharSet.Unicode)>

<DllImport("kernel32.dll", SetLastError:=True, EntryPoint:="FreeLibrary")> _

The original GetCommandLine function returns a pointer to a buffer allocated and owned by the operating system. When marshaling strings as return types, the interop marshaler assumes it must free the memory that the original LPTSTR type pointed to by the function. To prevent the marshaler from automatically reclaiming this memory, the managed GetCommandLine prototype returns an IntPtr type instead of a string. The Marshal.PtrToStringAuto method copies the unmanaged LPSTR type to a managed string object, widening the character format, if required.

    [DllImport("kernel32.dll", SetLastError=true, EntryPoint="GetCompressedFileSize")]

      //Need to use reflection to obtain pointer to the console output buffer

    [DllImport("kernel32.dll", EntryPoint = "GetConsoleOriginalTitleW", CharSet = CharSet.Unicode, SetLastError = true)]

    [DllImport("kernel32.dll", EntryPoint = "GetConsoleTitle", CharSet = CharSet.Unicode, SetLastError = true)]

    /// <param name="codePage">The code page 'pointer' to look up.</param>

  /// <param name="lpRootPathName">A pointer to a null-terminated string that specifies the root directory and returns information about the disk.A trailing backslash is required. If this parameter is NULL, the function uses the root of the current directory.</param>

catch (EntryPointNotFoundException)

Otherwise, an unhandled exception of type 'System.EntryPointNotFoundException' is thrown.

bufferLength, The maximum size of the buffer pointed to by buffer, in TCHARs. This size does not include the terminating null character. If this parameter is zero, buffer is not used.

buffer, A pointer to a buffer that receives a series of null-terminated strings, one for each valid drive in the system, plus with an additional null character. Each string is a device name.

[DllImport("KERNEL32.DLL", CharSet=CharSet::Auto, EntryPoint="GetPrivateProfileInt")]

    <DllImport("kernel32.dll", SetLastError:=True, EntryPoint:="GetPrivateProfileIntA")> _