private const short DEFAULT_RESULT_SIZE = 1024;

        StringBuilder outString = new StringBuilder(DEFAULT_RESULT_SIZE);

                DEFAULT_RESULT_SIZE, out lenNeeded))

                if (DEFAULT_RESULT_SIZE < lenNeeded)

        short error_size;

            out error_size)))

        int size;

        short rc = SQLGetData(statementHandle, colid, SQL_C_CHAR, val, val.Capacity, out size);

public static extern IntPtr FindFirstUrlCacheEntry([MarshalAs(UnmanagedType.LPTStr)] string lpszUrlSearchPattern,IntPtr lpFirstCacheEntryInfo,ref int lpdwFirstCacheEntryInfoBufferSize);

     ByRef lpdwFirstCacheEntryInfoBufferSize As Int32) As IntPtr

        int lpdwNextCacheEntryInfoBufferSize);

        ByRef lpdwNextCacheEntryInfoBufferSize As Integer) As Boolean

    public int dwStructSize;

    // (in) Size of the lpszUrl string, in TCHARs, or zero if lpszUrl is an ASCIIZ string

        // Determine the size of the cookie      

        UInt32 datasize = 256*1024;

        StringBuilder cookieData = new StringBuilder(Convert.ToInt32(datasize));

        if (!InternetGetCookieEx(url, null, cookieData, ref datasize, 0x00002000, IntPtr.Zero))

        if (datasize < 0)

        cookieData = new StringBuilder(Convert.ToInt32(datasize));

        if (!InternetGetCookieEx(url, null, cookieData, ref datasize, 0x00002000, IntPtr.Zero))

  Private _buffSize As Integer = 0

    'Call in once to get the size of the buffer we will need

    InternetGetLastResponseInfo(_errorCode, vbNullString, _buffSize)

    Dim message As String = Space(_buffSize + 1)

    InternetGetLastResponseInfo(_errorCode, message, _buffSize)

    /// size of the InternetPerConnOptionList struct

    public int dwSize;

private extern static bool InternetQueryVersion(int Handle, int OptionFlag, ref INTERNET_VERSION_INFO Version, ref int size);

int size = Marshal.SizeOf(Version);

bool r = InternetQueryVersion(0, INTERNET_OPTION_VERSION, ref Version, ref size);

     IntPtr intptrStruct = Marshal.AllocCoTaskMem(Marshal.SizeOf(struct_IPI));

     bool iReturn = InternetSetOption(IntPtr.Zero, INTERNET_OPTION_PROXY, intptrStruct, Marshal.SizeOf(struct_IPI));

<StructLayout(LayoutKind.Explicit, Size:=80)> _

    <FieldOffset(0)> Public dwStructSize As UInt32

    <FieldOffset(24)> Public dwSizeLow As UInt32

    <FieldOffset(28)> Public dwSizeHigh As UInt32

    <FieldOffset(68)> Public dwHeaderInfoSize As UInt32

<StructLayout(LayoutKind.Explicit, Size:=80)> _

    <FieldOffset(0)> Public dwStructSize As UInt32

    <FieldOffset(24)> Public dwSizeLow As UInt32

    <FieldOffset(28)> Public dwSizeHigh As UInt32

    <FieldOffset(68)> Public dwHeaderInfoSize As UInt32

    ' 1MB in size should be enough for this test

    Public dwStructSize As Integer

If the system must increase the size of the multiple-window- position structure beyond the initial size specified by the nNumWindows parameter but cannot allocate enough memory to do so, the system fails the entire window positioning sequence (BeginDeferWindowPos

d.cb = Marshal.SizeOf(d);

        public uint size;

        Public cbSize As UInteger

        filterStatus.size= (uint) Marshal.SizeOf(filterStatus);

        width = button.Size.Width;

        height = button.Size.Height;

                mii.cbSize = 48;

                sep.cbSize = 48;

            mii.cbSize = 48;

        mStuctLength = Marshal.SizeOf(typeof(SecurityAttributes));

                Win32.CW_USEDEFAULT, // initial x size

                Win32.CW_USEDEFAULT, // initial y size

    ///<Summary>Sends a WM_NCCALCSIZE message to the window, even if the window's size is not being changed. If this flag is not specified, WM_NCCALCSIZE is sent only when the window's size is being changed.</Summary>

    ///<Summary>Discards the entire contents of the client area. If this flag is not specified, the valid contents of the client area are saved and copied back into the client area after the window is sized or repositioned.</Summary>

    ///<Summary>Retains the current size (ignores the cx and cy parameters).</Summary>

    SWP_NOSIZE = 0x0001,

    '''<Summary>Sends a WM_NCCALCSIZE message to the window, even if the window's size is not being changed. If this flag is not specified, WM_NCCALCSIZE is sent only when the window's size is being changed.</Summary>

    '''<Summary>Discards the entire contents of the client area. If this flag is not specified, the valid contents of the client area are saved and copied back into the client area after the window is sized or repositioned.</Summary>

    '''<Summary>Retains the current size (ignores the cx and cy parameters).</Summary>

    SWP_NOSIZE = &H0001

    SWP_NOSIZE As Integer = &H0001

        internal const UInt32 SC_SIZE     =0xF000;

SC_SIZE = &HF000

        Size range = new Size(Math.Abs(newPt.X - pt.X), Math.Abs(newPt.Y - pt.Y));

        if (range.Height > SystemInformation.DragSize.Height

                || range.Width > SystemInformation.DragSize.Width)

      public RECT(System.Drawing.Point location, System.Drawing.Size size)

        Right = location.X + size.Width;

        Bottom = location.Y + size.Height;

      RECT from = new RECT(form.Location, form.Size);

            (System.Windows.Forms.SystemInformation.FrameBorderSize.Height * 2);

    RECT(System::Drawing::Point location, System::Drawing::Size size) {

        Right = location.X + size.Width;

        Bottom = location.Y + size.Height;

    RECT^ from=gcnew RECT(this->Location, this->Size);

        /// Size grip in lower-right corner of window

        DFCS_SCROLLSIZEGRIP = 8,

        /// Size grip in lower-left corner of window. This is used with right-to-left languages such as Arabic or Hebrew.

        DFCS_SCROLLSIZEGRIPRIGHT = 0x10,

The buttons are drawn by vectors so to draw a "menu" close icon simply draw a DFCS_CAPTIONCLOSE button with the size of SM_CXMENUCHECK/SM_CYMENUCHECK.

    d.cb=Marshal.SizeOf(d);

            d.cb=Marshal.SizeOf(d);

    dispDev1.cb = Marshal.SizeOf(dispDev1)

        mi.size = (uint)Marshal.SizeOf(mi);

    public UInt32 cbSize;

    fInfo.cbSize = Convert.ToUInt32(Marshal.SizeOf(fInfo));

        fInfo.cbSize = Convert.ToUInt32(Marshal.SizeOf(fInfo));

    Public cbSize As Long

        .cbSize = System.Runtime.InteropServices.Marshal.SizeOf(fwi)

    public UInt32 cbSize;

    fInfo.cbSize = Convert.ToUInt32(Marshal.SizeOf(fInfo));

        fInfo.cbSize = Convert.ToUInt32(Marshal.SizeOf(fInfo));

    Public cbSize As Long

        .cbSize = System.Runtime.InteropServices.Marshal.SizeOf(fwi)

The ManagedWindowsApi project (http://mwinapi.sourceforge.net) provides a KeyboardKey class to detect keyboard state and synthesize keyboard events.

Be sure to set cbSize member of WNDCLASSEX structure before calling the GetClassInfoEx function.

WNDCLASSEX wndClass = new WNDCLASSEX { cbSize = (uint)Marshal.SizeOf(typeof(WNDCLASSEX)) };

Be sure to set cbSize member of WNDCLASSEX structure before calling the GetClassInfoEx function.

WNDCLASSEX wndClass = new WNDCLASSEX { cbSize = (uint)Marshal.SizeOf(typeof(WNDCLASSEX)) };

    if (IntPtr.Size > 4)

    If IntPtr.Size > 4 Then

Testing the size of the IntPtr is the easiest way to determine if the platform is 64-bit.

    if (IntPtr.Size > 4)

    If IntPtr.Size > 4 Then

Testing the size of the IntPtr is the easiest way to determine if the platform is 64-bit.

     UIntPtr Length = GlobalSize(ClipboardDataPointer);

    public Int32 cbSize;

     Public cbSize As Int32

cbi.cbSize = System.Runtime.InteropServices.Marshal.SizeOf(cbi);

cbi.cbSize = System.Runtime.InteropServices.Marshal.SizeOf(cbi)

     public Int32 cbSize;        // Specifies the size, in bytes, of the structure.

                     // The caller must set this to Marshal.SizeOf(typeof(CURSORINFO)).

/// <summary>Must initialize cbSize</summary>

            pci.cbSize = Marshal.SizeOf(typeof(CURSORINFO));

    ByVal location As Point, ByVal size As Size) As Image

    Dim myImage As Image = New Bitmap(size.Width, size.Height)

    BitBlt(destDeviceContext, 0, 0, size.Width, size.Height, _

                    ByVal area As System.Drawing.Size) _

        public int cbSize;

        public IntPtr hwndMoveSize;

threadInfo.cbSize = Marshal.SizeOf( threadInfo );

        public int cbSize;

        public int hwndMoveSize;

        guiThreadInfo.cbSize = Marshal.SizeOf(guiThreadInfo);

        public int cbSize;

        public IntPtr hwndMoveSize;

        info.cbSize = Marshal.SizeOf(info);

   int nSize);

The ManagedWindowsApi project (http://mwinapi.sourceforge.net) provides a KeyboardKey class to detect keyboard state and synthesize keyboard events. It can also give you names of keys.

     size : int

        lastInputInfo.cbSize = (uint)Marshal.SizeOf( lastInputInfo );

    lastInputInf.cbSize = Marshal.SizeOf(lastInputInf)

    lastInputInfo.cbSize = (UInt32)Marshal::SizeOf(lastInputInfo);

     let size = Marshal.SizeOf (typeof<LastInputInfo>)

     let mutable info = { size = size; dwTime = 0u }

    lastInputInfo.cbSize = sizeof (lastInputInfo);

Make sure you set pmbi.cbSize to Marshal.SizeOf(typeof(MENUBARINFO)) before calling this function.

    public uint cbSize;

mif.cbSize = (uint)Marshal.SizeOf(typeof(MENUITEMINFO));

    mon_info.cbSize = (uint)Marshal.SizeOf(mon_info);

static extern int GetMouseMovePointsEx(uint cbSize, [In] ref MOUSEMOVEPOINT

                    uint  cbSize,

    int cpt = GetMouseMovePointsEx((uint)(Marshal.SizeOf(mp_in)), ref mp_in, mp_out, nNumPointsRequired, mode);

    /// <param name="pcbSize">Number of bytes in the array.</param>

    /// <param name="cbSizeHeader">Size of the header.</param>

    public static extern int GetRawInputData(IntPtr hRawInput, RawInputCommand uiCommand, out RAWINPUT pData, ref int pcbSize, int cbSizeHeader);

    /// <param name="pcbSize">Number of bytes in the array.</param>

    /// <param name="cbSizeHeader">Size of the header.</param>

    public static extern int GetRawInputData(IntPtr hRawInput, RawInputCommand uiCommand, byte[] pData, ref int pcbSize, int cbSizeHeader);

            int outSize = 0;

            int size = Marshal.SizeOf(typeof(RAWINPUT));

            outSize = Win32API.GetRawInputData(m.LParam, RawInputCommand.Input, out input, ref size, Marshal.SizeOf(typeof(RAWINPUTHEADER)));

            if (outSize != -1)

    public static extern uint GetRawInputDeviceInfo(int deviceHandle, uint command, ref DeviceInfo data, ref uint dataSize);

            public int Size;

    uint size = Marshal.SizeOf(typeof(User32.DeviceInfo));

    di.Size = Marshal.SizeOf(typeof(User32.DeviceInfo));

    User32.GetRawInputDeviceInfo(device.hDevice, User32.RIDI_DEVICEINFO, ref di, ref size);

static extern uint GetRawInputDeviceInfo(IntPtr hDevice, uint uiCommand, IntPtr pData, ref uint pcbSize);

Declare Function GetRawInputDeviceInfo Lib "user32.dll" Alias "GetRawInputDeviceInfoW" (ByVal hDevice As IntPtr, ByVal uiCommand As DeviceInfoTypes, ByVal pData As IntPtr, ByRef pcbSize As UInteger) As Integer

        public int cbSize;

        uint Size /* = (uint)Marshal.SizeOf(typeof(RawInputDeviceList)) */

    IntPtr, ByRef puiNumDevices As Int32, ByVal cbSize As Int32) As Int32

    IntPtr, ByRef puiNumDevices As Long, ByVal cbSize As Long) As Long

int structSize = Marshal.SizeOf(typeof(RAWINPUTDEVICELIST));    

IntPtr buffer = Marshal.AllocHGlobal(bufferCount * structSize);

int deviceCount = GetRawInputDeviceList(buffer, ref bufferCount, structSize);

new IntPtr((buffer.ToInt32() + (structSize * i))),typeof(RAWINPUTDEVICELIST));

        uint dwSize = (uint)Marshal.SizeOf(typeof(RAWINPUTDEVICELIST));

        // for the array to get the size needed for the list

        uint retValue = Win32API.GetRawInputDeviceList(null, ref deviceCount, dwSize);

        retValue = Win32API.GetRawInputDeviceList(deviceList, ref deviceCount, dwSize);

       //IntPtr pRawInputDeviceList = Marshal.AllocHGlobal((int)(dwSize * deviceCount));

    public int cbSize;

    [MarshalAs(UnmanagedType.ByValArray, SizeConst=6)]

psbi.cbSize = Marshal.SizeOf(psbi);

      int BORDERWIDTH = SystemInformation.Border3DSize.Width;

      si.cbSize = Marshal.SizeOf( si );

    Private Function GetScrollBarPageSize(ByVal hWnd As IntPtr, ByVal fnBar As Integer) As Integer

        .cbSize = Len(si)

Use the Form.ClientSize method to get the size of the working area of the window, which is much easier than calculating the system

  private const int UOI_HEAPSIZE = 5; //Windows Server 2003 and Windows XP/2000:  This value is not supported.

        ulong heapsize;

        if (GetUserObjectInformation(hdesk, UOI_HEAPSIZE, out heapsize, sizeof(ulong), out lengthNeeded))

            Text = "Heapsize:" + heapsize;

You must assign the cbSize parameter prior to calling GetWindowInfo(). For example:

    info.cbSize = (uint)Marshal.SizeOf(info);

    info.cbSize = Convert.ToUInt32(Marshal.SizeOf(info))

To make your code work on both Win32 and Win64, you can detect the size of IntPtr, and call the appropriate function. You will have to give the two functions different names, of course.

     if (IntPtr.Size == 8)

     If IntPtr.Size = 8 Then

To make your code work on both Win32 and Win64, you can detect the size of IntPtr, and call the appropriate function. You will have to give the two functions different names, of course.

     if (IntPtr.Size == 8)

     If IntPtr.Size = 8 Then

/// Before calling GetWindowPlacement, set the length member to sizeof(WINDOWPLACEMENT). GetWindowPlacement fails if lpwndpl-> length is not set correctly.

       placement.length = Marshal.SizeOf(placement);

        wpTemp.Length = System.Runtime.InteropServices.Marshal.SizeOf(wpTemp)

            this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);

            this.ClientSize = new System.Drawing.Size(528, 266);