out IntPtr NTEContext, out IntPtr NTEInstance );

                  out IntPtr NTEContext, out IntPtr NTEInstance );

        IntPtr ptrMyNTEContext = new IntPtr(MyNTEContext);

        IntPtr ptrMyNTEInstance = new IntPtr(MyNTEInstance);

static extern int EnableRouter(IntPtr pHandle, ref System.Threading.NativeOverlapped pOverlapped);

    Public Shared Function EnableRouter(pHandle As IntPtr, ByRef pOverlapped As OVERLAPPED) As Integer

    Public Pointer As IntPtr

    Public hEvent As IntPtr

    Public Shared Function EnableRouter(pHandle As IntPtr, ByRef pOverlapped As OVERLAPPED) As Integer

    Public Shared Function CreateEvent(lpEventAttributes As IntPtr, ByVal bManualReset As Boolean, ByVal bInitialState As Boolean, ByVal lpName As String) As IntPtr

    pOverlapped.hEvent = CreateEvent(IntPtr.Zero, False, False, "enablerouter")

    Dim RetVal As Integer = EnableRouter(IntPtr.Zero, pOverlapped)

        public IntPtr CurrentDnsServer;

private static extern ERROR GetAdaptersAddresses(uint Family, uint Flags, IntPtr Reserved, IntPtr pAdapterAddresses, ref uint pOutBufLen);

        public IntPtr lpSockAddr;

        public IntPtr Next;

        public IntPtr Next;

        public IntPtr FirstUnicastAddress;

        public IntPtr FirstAnycastAddress;

        public IntPtr FirstMulticastAddress;

        public IntPtr FirstDnsServerAddress;

        public IntPtr FirstPrefix;

        public IntPtr FirstWinsServerAddress;

        public IntPtr FirstGatewayAddress;

    private static extern ERROR GetAdaptersAddresses(uint Family, uint Flags, IntPtr Reserved, IntPtr pAdapterAddresses, ref uint pOutBufLen);

    public static string MarshalString(IntPtr text)

        ERROR err = GetAdaptersAddresses((uint)family, (uint)0, IntPtr.Zero, IntPtr.Zero, ref outBufLen);

        IntPtr pAdapterAddresses = Marshal.AllocHGlobal((int)outBufLen);

            err = GetAdaptersAddresses((uint)family, (uint)0, IntPtr.Zero, pAdapterAddresses, ref outBufLen);

            IntPtr currPtr = pAdapterAddresses;

            while (IntPtr.Zero != currPtr)

        if (IntPtr.Zero != addr.FirstUnicastAddress)

            if (IntPtr.Zero != unicastAddr.Address.lpSockAddr)

public static extern int GetAdaptersInfo(IntPtr pAdapterInfo, ref Int64 pBufOutLen);

     ByVal pAdapterInfo As IntPtr, _

     Dim pArray As IntPtr = Marshal.AllocHGlobal(structSize)

     pArray = Marshal.ReAllocHGlobal(pArray, New IntPtr(Convert.ToInt64(len)))

     Dim pEntry As IntPtr = pArray

     Loop Until IntPtr.op_Equality(pEntry, IntPtr.Zero)

   IntPtr pArray = Marshal.AllocHGlobal( new IntPtr(structSize) );

     pArray = Marshal.ReAllocHGlobal( pArray, new IntPtr (structSize) );

     IntPtr pEntry = pArray;

     while( pEntry != IntPtr.Zero );

static extern uint GetExtendedTcpTable(IntPtr pTcpTable, ref int dwOutBufLen, bool sort, int ipVersion, TCP_TABLE_CLASS tblClass,uint reserved = 0);

Public Shared Function GetExtendedTcpTable(ByVal pTcpTable As IntPtr, ByRef dwOutBufLen As Integer, ByVal sort As Boolean, ByVal ipVersion As  Integer, ByVal tblClass As TCP_TABLE_CLASS, ByVal reserved As Integer) As UInteger

    uint ret = GetExtendedTcpTable(IntPtr.Zero, ref buffSize, true, ipVersion, TCP_TABLE_CLASS.TCP_TABLE_OWNER_PID_ALL);

    IntPtr tcpTablePtr = Marshal.AllocHGlobal(buffSize);

        IntPtr rowPtr = (IntPtr)((long)tcpTablePtr + 4);

            rowPtr = (IntPtr)((long)rowPtr + rowStructSize);   // next entry

    uint ret = GetExtendedTcpTable(IntPtr.Zero, ref buffSize, true, AF_INET, TCP_TABLE_CLASS.TCP_TABLE_OWNER_PID_ALL);        

    IntPtr buffTable = Marshal.AllocHGlobal(buffSize);

        IntPtr rowPtr = (IntPtr)((long)buffTable + Marshal.SizeOf(tab.dwNumEntries));

            rowPtr = (IntPtr)((long)rowPtr + Marshal.SizeOf(tcpRow));   // next entry

          IntPtr tcpTable,

          uint ret = IPHelperAPI.GetExtendedTcpTable(IntPtr.Zero, ref buffSize, true, ipVersion, TCP_TABLE_CLASS.TCP_TABLE_OWNER_PID_ALL);

          IntPtr tcpTablePtr = Marshal.AllocHGlobal(buffSize);

          IntPtr rowPtr = (IntPtr)((long)tcpTablePtr + 4);

              rowPtr = (IntPtr)((long)rowPtr + rowStructSize);   // next entry

    Dim Ret As UInteger = GetExtendedTcpTable(IntPtr.Zero, BufLen, True, AF_INET, TCP_TABLE_CLASS.TCP_TABLE_OWNER_PID_ALL, 0)

    Dim TblPtr As IntPtr = Marshal.AllocHGlobal(BufLen)

    Dim RowArrayPtr As IntPtr = CType((CLng(TblPtr) + CLng(Marshal.OffsetOf(GetType(MIB_TCPTABLE_OWNER_PID), "table"))), IntPtr)

        RowArrayPtr = CType((CLng(RowArrayPtr) + RowStructSize), IntPtr)

    public static extern uint GetIfTable(IntPtr pIfTable, ref uint pdwSize, bool bOrder);

        IPHelperTraslation.GetIfTable(IntPtr.Zero, ref size, false);

        IntPtr buf = Marshal.AllocHGlobal((int)size);

        mRows[i] = (IPHelperTraslation.MIB_IFROW)Marshal.PtrToStructure((IntPtr)pRows, typeof(IPHelperTraslation.MIB_IFROW));

            Marshal.Copy(buffer, 0, new IntPtr(&iNumAdapters), 4);

            IntPtr ptr = Marshal.AllocHGlobal(Marshal.SizeOf(map));

public static extern int GetIpAddrTable(IntPtr pIpAddrTable, ref int pdwSize, bool bOrder);

GetIpAddrTable Lib "iphlpapi.dll" (ByRef ipTable As IntPtr, ByRef tableSize As IntPtr, ByVal ordered As Boolean) As UInt32

static UInt32 GetIpAddressTable( [Out] IntPtr ipTable, [In,Out] IntPtr tableSize, bool sort);

IntPtr pBuf = IntPtr.Zero;

GetIpAddrTable( IntPtr.Zero, ref nBufSize, false );

    IntPtr pEntry = (IntPtr)(tableStartAddr + i * entrySize);

if ( pBuf != IntPtr.Zero )

static extern int GetIpNetTable(IntPtr pIpNetTable, ref int pdwSize, bool bOrder);

    Private Shared Function GetIpNetTable(pIpNetTable As IntPtr, <MarshalAs(UnmanagedType.U4)> ByRef pdwSize As Integer, bOrder As Boolean) As <MarshalAs(UnmanagedType.U4)> Integer

         IntPtr pIpNetTable,

         int result = GetIpNetTable(IntPtr.Zero, ref bytesNeeded, false);

         IntPtr buffer = IntPtr.Zero;

            IntPtr currentBuffer = new IntPtr(buffer.ToInt64() +

              IntPtr(currentBuffer.ToInt64() + (index *

    Dim result As Integer = GetIpNetTable(IntPtr.Zero, bytesNeeded, False)

    Dim buffer As IntPtr = IntPtr.Zero

        Dim currentBuffer As New IntPtr(buffer.ToInt64() + Marshal.SizeOf(GetType(Integer)))

        table(index) = DirectCast(Marshal.PtrToStructure(New IntPtr(currentBuffer.ToInt64() + (index * Marshal.SizeOf(GetType(MIB_IPNETROW)))), GetType(MIB_IPNETROW)), MIB_IPNETROW)

public static extern int GetNetworkParams(IntPtr pFixedInfo, ref UInt32 pBufOutLen);

    Public Shared Function GetNetworkParams(pFixedInfo As IntPtr, ByRef pBufOutLen As Integer) As Integer

IntPtr infoPtr = IntPtr.Zero;

    Public CurrentDnsServer As IntPtr

    Private Shared Function GetNetworkParams(pFixedInfo As IntPtr, ByRef pBufOutLen As Integer) As Integer

    Dim infoPtr As IntPtr = IntPtr.Zero

        Marshal.Copy(buffer, 0, new IntPtr(&iNumAdapters), 4);

        IntPtr ptr = Marshal.AllocHGlobal(Marshal.SizeOf(map));

        private static extern int GetIpNetTable(IntPtr pIpNetTable, ref int pdwSize, bool bOrder);

    internal static extern UInt32 PfAddFiltersToInterface(IntPtr ih, UInt32 cInFilters,

    [MarshalAsAttribute(UnmanagedType.Struct)] ref PPF_FILTER_DESCRIPTOR pFiltOut, IntPtr pfHandle);

        IntPtr interfaceHandle = new IntPtr();

            IntPtr filterHandle = new IntPtr();

    static extern uint PfBindInterfaceToIPAddress(IntPtr Interface_handle, uint pfatType, ref uint IPAddress);

        IntPtr interfaceHandle = new IntPtr();

            IntPtr filterHandle = new IntPtr();

    static extern Int32 PfCreateInterface(int dwName, uint inAction, uint outAction, int bUseLog, int bMustBeUnique, ref IntPtr ppInterface);

        IntPtr interfaceHandle = new IntPtr();

            IntPtr filterHandle = new IntPtr();

    static extern UInt32 PfDeleteInterface(IntPtr pInterface);

    static extern uint PfRemoveFiltersFromInterface(IntPtr ih, uint cInFilters,

    public static extern UInt32 PfTestPacket(IntPtr pInInterface, IntPtr pOutInterface, uint cBytes, IntPtr pbPacket, ref PFFORWARD_ACTION ppAction);

static extern int SetTcpEntry(IntPtr pTcprow);

Declare Function SetTCPEntry Lib "iphlpapi.dll" (IntPtr pTcprow) As int

           IntPtr ptr = GetPtrToNewObject(rows[i]);

static extern int UnenableRouter(ref System.Threading.NativeOverlapped pOverlapped, IntPtr lpdwEnableCount);

    Public Shared Function UnenableRouter(pOverlapped As IntPtr, ByRef lpdwEnableCount As Long) As Integer

    Public Pointer As IntPtr

    Public hEvent As IntPtr

    Public Shared Function UnenableRouter(pOverlapped As IntPtr, ByRef lpdwEnableCount As Long) As Integer

    Public Shared Function CloseHandle(ByVal hwn As IntPtr) As Long

    Dim pOverlappedPtr As IntPtr

        If pOverlapped.hEvent = IntPtr.Zero Then Exit Sub ' We don't have the handle.

        If pOverlappedPtr <> IntPtr.Zero Then CloseHandle(pOverlapped.hEvent)

static extern int ComDBClaimPort(IntPtr hComDB, out int ComNumber)

static extern int ComDBClaimPort(IntPtr hComDB, int ComNumber, [MarshalAs(UnmanagedType.Bool)] bool ForceClaim, [MarshalAs(UnmanagedType.Bool)] out bool Forced);

static extern int ComDBClose(IntPtr hComDB);

static extern int ComDBOpen(out IntPtr hComDB);

static extern int ComDBReleasePort(IntPtr hComDB, int ComNumber);

static extern int SerialDisplayAdvancedSettings(IntPtr parentHwnd, IntPtr deviceInfoSet, ref SP_DEVINFO_DATA deviceInfoData);

IntPtr deviceInfoSetHandle = NativeMethods.SetupDiGetClassDevs(ref deviceClassGuid, null, IntPtr.Zero, DIGCF_PRESENT);

            NativeMethods.SerialDisplayAdvancedSettings(IntPtr.Zero, deviceInfoSetHandle, ref deviceInfoData);

    public static extern void glCallLists(int n, uint type, IntPtr lists);

    public static extern void glReadPixels(int x, int y, int width, int height, uint format, uint type, IntPtr pixels);

    public static extern void glTexImage2D(uint target, int level, int internalformat, int width, int height, int border, uint format, uint type, IntPtr pixels);

    public static extern void gluBuild1DMipmaps(uint target, uint components, int width, uint format, uint type, IntPtr data);

    public static extern void gluBuild2DMipmaps(uint target, uint components, int width, int height, uint format, uint type, IntPtr data);

    public static extern IntPtr gluNewQuadric();

    public static extern void gluDeleteQuadric(IntPtr state);

    public static extern void gluQuadricNormals(IntPtr quadObject, uint normals);

    public static extern void gluQuadricTexture(IntPtr quadObject, int textureCoords);

    public static extern void gluQuadricOrientation(IntPtr quadObject, int orientation);

    public static extern void gluQuadricDrawStyle(IntPtr quadObject, uint drawStyle);

    public static extern void gluCylinder(IntPtr qobj, double baseRadius, double topRadius, double height, int slices, int stacks);

    public static extern void gluDisk(IntPtr qobj, double innerRadius, double outerRadius, int slices, int loops);

    public static extern void gluPartialDisk(IntPtr qobj, double innerRadius, double outerRadius, int slices, int loops, double startAngle, double sweepAngle);

    public static extern void gluSphere(IntPtr qobj, double radius, int slices, int stacks);

    public static extern IntPtr gluNewTess();

    public static extern void gluDeleteTess(IntPtr tess);

    public static extern void gluTessBeginPolygon(IntPtr tess, IntPtr polygonData);

    public static extern void gluTessBeginContour(IntPtr tess);

    public static extern void gluTessVertex(IntPtr tess, double[] coords, double[] data);

    public static extern void gluTessEndContour(IntPtr tess);

    public static extern void gluTessEndPolygon(IntPtr tess);

    public static extern void gluTessProperty(IntPtr tess, int which, double value);

    public static extern void gluTessNormal(IntPtr tess, double x, double y, double z);

    //[DllImport("Glu32.dll")] public static extern void gluTessCallback(IntPtr tess, int which, SharpGL.Delegates.Tesselators.Begin callback);

    //[DllImport("Glu32.dll")] public static extern void gluTessCallback(IntPtr tess, int which, SharpGL.Delegates.Tesselators.BeginData callback);

    //[DllImport("Glu32.dll")] public static extern void gluTessCallback(IntPtr tess, int which, SharpGL.Delegates.Tesselators.Combine callback);

    //[DllImport("Glu32.dll")] public static extern void gluTessCallback(IntPtr tess, int which, SharpGL.Delegates.Tesselators.CombineData callback);

    //[DllImport("Glu32.dll")] public static extern void gluTessCallback(IntPtr tess, int which, SharpGL.Delegates.Tesselators.EdgeFlag callback);

    //[DllImport("Glu32.dll")] public static extern void gluTessCallback(IntPtr tess, int which, SharpGL.Delegates.Tesselators.EdgeFlagData callback);

    //[DllImport("Glu32.dll")] public static extern void gluTessCallback(IntPtr tess, int which, SharpGL.Delegates.Tesselators.End callback);

    //[DllImport("Glu32.dll")] public static extern void gluTessCallback(IntPtr tess, int which, SharpGL.Delegates.Tesselators.EndData callback);

    //[DllImport("Glu32.dll")] public static extern void gluTessCallback(IntPtr tess, int which, SharpGL.Delegates.Tesselators.Error callback);

    //[DllImport("Glu32.dll")] public static extern void gluTessCallback(IntPtr tess, int which, SharpGL.Delegates.Tesselators.ErrorData callback);

    //[DllImport("Glu32.dll")] public static extern void gluTessCallback(IntPtr tess, int which, SharpGL.Delegates.Tesselators.Vertex callback);

    //[DllImport("Glu32.dll")] public static extern void gluTessCallback(IntPtr tess, int which, SharpGL.Delegates.Tesselators.VertexData callback);

    public static extern void gluGetTessProperty(IntPtr tess, int which, double value);

    public static extern IntPtr gluNewNurbsRenderer();

    public static extern void gluDeleteNurbsRenderer(IntPtr nobj);

    public static extern void gluBeginSurface(IntPtr nobj);

    public static extern void gluBeginCurve(IntPtr nobj);

    public static extern void gluEndCurve(IntPtr nobj);

    public static extern void gluEndSurface(IntPtr nobj);

    public static extern void gluBeginTrim(IntPtr nobj);

    public static extern void gluEndTrim(IntPtr nobj);

    public static extern void gluPwlCurve(IntPtr nobj, int count, float array, int stride, uint type);

    public static extern void gluNurbsCurve(IntPtr nobj, int nknots, float[] knot, int stride, float[] ctlarray, int order, uint type);

    public static extern void gluNurbsSurface(IntPtr nobj, int sknot_count, float[] sknot, int tknot_count, float[] tknot, int s_stride, int t_stride, float[] ctlarray, int sorder, int torder, uint type);

    public static extern void gluLoadSamplingMatrices(IntPtr nobj, float[] modelMatrix, float[] projMatrix, int[] viewport);

    public static extern void gluNurbsProperty(IntPtr nobj, int property, float value);

    public static extern void gluGetNurbsProperty(IntPtr nobj, int property, float value);

    public static extern void IntPtrCallback(IntPtr nobj, int which, IntPtr Callback);

IntPtr hDC,

        IntPtr _OldFontH = IntPtr.Zero;

                IntPtr dc = pe.Graphics.GetHdc();

                IntPtr fontH = font.ToHfont();

                IntPtr dc = pe.Graphics.GetHdc();

                IntPtr disposeFontH = Gdi.SelectObject(dc, _OldFontH);

static extern bool MiniDumpWriteDump(IntPtr hProcess, uint ProcessId, IntPtr hFile, int DumpType, ref MINIDUMP_EXCEPTION_INFORMATION ExceptionParam, IntPtr UserStreamParam, IntPtr CallbackParam);

static extern bool MiniDumpWriteDump(IntPtr hProcess, uint ProcessId, IntPtr hFile, int DumpType,

    ref MINIDUMP_EXCEPTION_INFORMATION ExceptionParam, IntPtr UserStreamParam, IntPtr CallbackParam);

static extern IntPtr GetCurrentProcess();

    public IntPtr ExceptionPointers;

    MiniDumpWithFullMemory, ref info, IntPtr.Zero, IntPtr.Zero );

   [MarshalAs(UnmanagedType.IUnknown)] object pUnk, IntPtr lpvReserved);

Marshal.ThrowExceptionForHR ( CoCreateGuid ( out guid ) , new IntPtr ( -1 ) );

   IntPtr pServerInfo,

   IntPtr pServerInfo,

static extern void CoDisableCallCancellation(IntPtr pvReserved);

static extern void CoEnableCallCancellation(IntPtr pvReserved);

   IntPtr pServerInfo,

    ByVal pServerInfo As IntPtr, _

static extern int CoGetInstanceFromFile(IntPtr pServerInfo, [In] ref Guid

  [Out] out System.IntPtr ppv

IntPtr unk = 0;

public static extern int CoInitializeSecurity( IntPtr pVoid, int

    cAuthSvc,IntPtr asAuthSvc, IntPtr pReserved1, RpcAuthnLevel level,

    RpcImpLevel impers,IntPtr pAuthList, EoAuthnCap dwCapabilities, IntPtr

Declare Function CoInitializeSecurity Lib "ole32.dll" (pVoid As IntPtr, _

   pReserved1 As IntPtr, dwAuthnLevel As Integer, dwImpLevel As Integer, _

   pAuthList As IntPtr, dwCapabilities As Integer, pReserved3 As IntPtr) As Integer

    CoInitializeSecurity( IntPtr.Zero, -1, IntPtr.Zero,

        IntPtr.Zero,RpcAuthnLevel.None ,

        RpcImpLevel.Impersonate,IntPtr.Zero, EoAuthnCap.None, IntPtr.Zero );

        [In, Optional] IntPtr pvReserved,

public static extern int CoInitializeSecurity( IntPtr pVoid, int

    cAuthSvc,IntPtr asAuthSvc, IntPtr pReserved1, RpcAuthnLevel level,

    RpcImpLevel impers,IntPtr pAuthList, EoAuthnCap dwCapabilities, IntPtr

Declare Function CoInitializeSecurity Lib "ole32.dll" (pVoid As IntPtr, _

   pReserved1 As IntPtr, dwAuthnLevel As Integer, dwImpLevel As Integer, _

   pAuthList As IntPtr, dwCapabilities As Integer, pReserved3 As IntPtr) As Integer

    CoInitializeSecurity( IntPtr.Zero, -1, IntPtr.Zero,

        IntPtr.Zero,RpcAuthnLevel.None ,

        RpcImpLevel.Impersonate,IntPtr.Zero, EoAuthnCap.None, IntPtr.Zero );

   IntPtr pvDestContext, MSHLFLAGS mshlflags);

    static extern int CoQueryClientBlanket(out IntPtr pAuthnSvc, out IntPtr pAuthzSvc,

        [MarshalAs(UnmanagedType.LPWStr)] out StringBuilder pServerPrincName, out IntPtr

        pAuthnLevel, out IntPtr pImpLevel, out IntPtr pPrivs, out IntPtr pCapabilities);

    System.IntPtr pAthnSvc = new IntPtr();

    System.IntPtr pAthzSvc = new IntPtr();

    System.IntPtr pAuthnLevel = new IntPtr();

    System.IntPtr pImpLevel = new IntPtr();

    System.IntPtr pPrivs = new IntPtr();

    System.IntPtr pCaps = new IntPtr(4);

   uint dwImpLevel, IntPtr pAuthInfo, uint dwCapabilities);

static extern void CoTaskMemFree(IntPtr pv);

   uint cHandles, IntPtr [] pHandles, out uint lpdwindex);

    System.IntPtr[] waitHandles = { event.SafeWaitHandle.DangerousGetHandle() };

    public extern static int CreateILockBytesOnHGlobal(IntPtr hGlobal, [MarshalAs(UnmanagedType.Bool)] bool fDeleteOnRelease, out ILockBytes ppLkbyt);

static extern int CreateILockBytesOnHGlobal(IntPtr /* HGLOBAL */ hGlobal, bool fDeleteOnRelease, [MarshalAs(UnmanagedType.Interface)]out object /* ILockBytes** */ ppLkbyt);

    Public Shared Function CreateILockBytesOnHGlobal(ByVal hGlobal As IntPtr, _

hr = Win32.CreateILockBytesOnHGlobal(IntPtr.Zero, True, lockbytes)

static extern int CreateStreamOnHGlobal(IntPtr hGlobal, bool fDeleteOnRelease,

    Declare Function CreateStreamOnHGlobal Lib "ole32" (ByVal hGlobal As IntPtr, ByVal fDeleteOnRelease As Boolean, ByRef ppstm As UCOMIStream) As Long

    extern public static int CreateStreamOnHGlobal(IntPtr ptr, bool delete, out System.Runtime.InteropServices.ComTypes.IStream pOutStm);

    public extern static void GetHGlobalFromStream(IStream stm, ref IntPtr hGlobal);

        IntPtr  pIPStream = IntPtr.Zero;

        IntPtr  hGlobalMemHandle = (IntPtr)null;

        IntPtr  pIUnk = IntPtr.Zero;

        if (pIUnk == IntPtr.Zero)

                IntPtr nativePtr = Marshal.AllocHGlobal(SizeOfIstream); //buffer.Length); // allocate space on the native heap

    static extern int GetHGlobalFromILockBytes(ILockBytes pLkbyt, out IntPtr phglobal);

static extern int GetHGlobalFromILockBytes([MarshalAs(UnmanagedType.Interface)] object /* ILockBytes* */pLkbyt, out IntPtr /* HGLOBAL* */ phglobal);

static extern void OleCreatePropertyFrame(IntPtr hwndOwner, int x, int y,

    (ByVal hwndOwner As IntPtr, _

    ByVal pvReserved As IntPtr) As Integer

                if( cauuid.pElems != IntPtr.Zero )

    static extern int OleCreatePropertyFrame(IntPtr hwndOwner,

7/6/2012 Dan Woerner : Changed olepro32.dll to oleaut32.dll because olepro32 doesn't work for x64, also changed the uint/UINT32/(and IntPtr reserved) to int because they are easier to deal with

static extern IOleObject OleCreateFromData (IDataObject pSrcDataObj, ref Guid riid, OLERENDER renderopt, IntPtr pFormatEtc, IOleClientSite pClientSite, IStorage pStg);

static extern void OleCreatePropertyFrame(IntPtr hwndOwner, uint x, uint y,

    uint lcid, UInt32 dwReserved, IntPtr lpvReserved);

    (ByVal hwndOwner As IntPtr, _

    ByVal pvReserved As IntPtr) As Integer

      uint dwAspect, IntPtr hdcDraw, [In] ref RECT lprcBounds);

       public static extern int OleDraw(IntPtr pUnk, int dwAspect, IntPtr hdcDraw, ref Rectangle lprcBounds);

           IntPtr pUnk = Marshal.GetIUnknownForObject(c.GetOcx());

           IntPtr hdc = graphics.GetHdc();

  static extern void OleInitialize(IntPtr pvReserved);

      pStm.Read(data, sizeof(ushort), IntPtr.Zero);

      pStm.Read(data, sizeof(ushort), IntPtr.Zero);

  static extern int OleRegGetUserType([In] ref Guid clsid, uint dwFormOfType, out IntPtr pszBuff);

    IntPtr pszBuf;

IntPtr pUnknown = Marshal.GetIUnknownForObject(fooObject);

    extern public static int CreateStreamOnHGlobal(IntPtr ptr, bool delete, out System.Runtime.InteropServices.ComTypes.IStream pOutStm);

         IntPtr  ptrIStream = IntPtr.Zero;

        pOutStm.Seek(0, 0, IntPtr.Zero);// Get size of the stream and read its contents to a byte array.

        IntPtr pRead = Marshal.AllocHGlobal(sizeOfInt32);