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,

Bring to the table win-win survival strategies to ensure proactive domination. At the end of the day, going forward, a new normal that has evolved from generation X is on the runway heading towards a streamlined cloud solution. User generated content in real-time will have multiple touchpoints for offshoring.

  __in  LPEXCEPTION_POINTERS pep,

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")> _

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

[DllImport("KERNEL32.DLL", CharSet=CharSet::Ansi, EntryPoint="GetProcAddress", ExactSpelling=true)]

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:

DllRegisterServerInvoker drs = (DllRegisterServerInvoker) Marshal.GetDelegateForFunctionPointer( fptr, typeof(DllRegisterServerInvoker) );

drs(); // call via a function pointer

[DllImport("kernel32", SetLastError = true, EntryPoint = "GetProcAddress")]

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

[DllImport("kernel32.dll",EntryPoint="GetStartupInfoW")]

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

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

Note that there are two entrypoints to GetTempPath in kernel32.dll called "GetTempPathA" and "GetTempPathW". So if you want to use GetTempPath you have to set the EntryPoint on the DllImport-Attribute as follows (C#):

[DllImport("kernel32.dll", EntryPoint = "GetTempPathA")]

   CONTEXT_FLOATING_POINT = CONTEXT_i386 | 0x08, // 387 state

   CONTEXT_ALL = CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS |  CONTEXT_FLOATING_POINT | CONTEXT_DEBUG_REGISTERS |  CONTEXT_EXTENDED_REGISTERS

     // Retrieved by CONTEXT_FLOATING_POINT

Although the API returns times in 100 nanosecond units, the precision is only to that of the process scheduler, about 15 milliseconds (depending on OS version). So don't expect pinpoint accuracy on short running functions.

/// <param name="lpTimeZoneInformation">[out] Pointer to a TIME_ZONE_INFORMATION structure to receive the current time-zone parameters.</param>

/// <param name="lpTimeZoneInformation">[in] Pointer to a TIME_ZONE_INFORMATION structure that contains the time-zone parameters to set.</param>

  /// Pointer to a null-terminated string associated with standard time. For example, "EST" could indicate Eastern Standard Time. The string will be returned unchanged by the GetTimeZoneInformation function. This string can be empty.

  /// Pointer to a null-terminated string associated with daylight saving time. For example, "PDT" could indicate Pacific Daylight Time. The string will be returned unchanged by the GetTimeZoneInformation function. This string can be empty.

    /// The file system supports re-parse points.

    SupportsReparsePoints = 0x80,

static extern bool GetVolumeNameForVolumeMountPoint(string

   lpszVolumeMountPoint, [Out] StringBuilder lpszVolumeName,

public static string GetVolumeName(string MountPoint)

     if (!GetVolumeNameForVolumeMountPoint(MountPoint, sb, (uint) MaxVolumeNameLength))

    EntryPoint:="GetVolumePathNamesForVolumeNameW")> _

The VB Code was generated by the tool at http://clrinterop.codeplex.com/releases/view/14120. I believe this to be the same tool referenced at http://blogs.msdn.com/b/vbteam/archive/2008/03/14/making-pinvoke-easy.aspx. The StringBuilder limitation appears to apply to this code as well, and it will only return the first path/mountpoint found, but the method does work inside that limitation. I will post updated code as soon as I code and test.

    public List<string> GetMountPointsForVolume(string volumeDeviceName)

    ' Have to use Pointer to return pathnames, StringBuilder only returns first NULL-terminated string

                EntryPoint:="GetVolumePathNamesForVolumeNameW", _

    Public Shared Function GetMountPointsPtr(ByVal sVolumeName As String, _

    ListMountPoints()

    Private Sub ListMountPoints(Optional strVolumeName As String = _

        PInvoke.GetMountPointsPtr(strVolumeName, lpBuffer, uintBufferLen, uintRequiredBufferLen)

        If CBool(Not (PInvoke.GetMountPointsPtr(strVolumeName, lpBuffer, _

        Throw New ApplicationException("Exception Occured invoking GetMountPointsPtr()!")

        ' retrieve the mountpoints(s)

        Console.WriteLine(strVolumeName + " has the following mountpoints: " _

    EntryPoint:="GetVolumePathNamesForVolumeNameW")> _

The VB Code was generated by the tool at http://clrinterop.codeplex.com/releases/view/14120. I believe this to be the same tool referenced at http://blogs.msdn.com/b/vbteam/archive/2008/03/14/making-pinvoke-easy.aspx. The StringBuilder limitation appears to apply to this code as well, and it will only return the first path/mountpoint found, but the method does work inside that limitation. I will post updated code as soon as I code and test.

    public List<string> GetMountPointsForVolume(string volumeDeviceName)

    ' Have to use Pointer to return pathnames, StringBuilder only returns first NULL-terminated stgring

                EntryPoint:="GetVolumePathNamesForVolumeNameW", _

    Public Shared Function GetMountPointsPtr(ByVal sVolumeName As String, _

    ListMountPoints()

    Private Sub ListMountPoints(Optional strVolumeName As String = "\\?\Volume{9a615499-414c-11e0-bd72-78e7d1722cbc}\")

        PInvoke.GetMountPointsPtr(strVolumeName, lpBuffer, uintBufferLen, uintRequiredBufferLen)

        If CBool(Not (PInvoke.GetMountPointsPtr(strVolumeName, lpBuffer, _

        ' retrieve the mountpoints(s)

        Console.WriteLine(strVolumeName + " has the following mountpoints: " _

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

    <DllImport("KERNEL32.DLL", EntryPoint:="GlobalAlloc", _

Retrieves the handle associated with the specified pointer to a global memory block.

    [DllImport( "kernel32.dll", CharSet = CharSet.Auto, EntryPoint = "GlobalMemoryStatusEx", SetLastError = true )]

    [DllImport( "kernel32.dll", CharSet = CharSet.Auto, EntryPoint = "GlobalMemoryStatusEx", SetLastError = true )]

Result - A pointer to a value that receives TRUE if the process is running in the job, and FALSE otherwise.

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

    /// On a Pentium, a floating-point precision error can occur in rare circumstances

    FloatingPointPrecisionErrata = 0,

    /// Floating-point operations are emulated using a software emulator.

    /// This function returns a nonzero value if floating-point operations are emulated; otherwise, it returns zero.

    FloatingPointEmulated = 1,

If a zero pointer is returned, the system is out of memory and you should throw an OutOfMemoryException.

this function returnes a pointer to the resource. you can use Marshal.Copy() to copy the data from the pointer to a managed array.

    throw new ApplicationException("could not get pointer to file");

    [DllImport("Kernel32.dll", EntryPoint = "FindResourceW", SetLastError = true, CharSet = CharSet.Unicode)]

    [DllImport("Kernel32.dll", EntryPoint = "SizeofResource", SetLastError = true)]

    [DllImport("Kernel32.dll", EntryPoint = "LoadResource", SetLastError = true)]

    [DllImport("Kernel32.dll", EntryPoint = "LockResource")]

        (int)pm.EntryPointAddress, (int)pm.BaseAddress + pm.ModuleMemorySize, pm.ModuleName);