[Question] How to properly use void* in DwmGetWindowAttribute ?

[Micke3rd]

Hi,
DwmGetWindowAttribute is generated as
public static extern unsafe winmdroot.Foundation.HRESULT DwmGetWindowAttribute(winmdroot.Foundation.HWND hwnd, winmdroot.Graphics.Dwm.DWMWINDOWATTRIBUTE dwAttribute, void* pvAttribute, uint cbAttribute);

My current attempt is

       var rect = default(Windows.Win32.Foundation.RECT);
        var size = Marshal.SizeOf(rect);
        var ptr = Marshal.AllocHGlobal(size);
        Marshal.StructureToPtr(rect, ptr,true);
        var result = Windows.Win32.PInvoke.DwmGetWindowAttribute(hwnd,
                            Windows.Win32.Graphics.Dwm.DWMWINDOWATTRIBUTE.DWMWA_EXTENDED_FRAME_BOUNDS
                           , ptr     // error  'cannot convert ... to void*'     <---
                          , (uint)size);
        Marshal.FreeHGlobal(size);

I've seen the post saying so soon you'll see out object instead of void** or out void* , but a few months have passed since then.

thank you in advance

Context

CsWin32 version: [0.2.188-beta]
Target Framework: net7.0-windows
LangVersion (if explicitly set by project): latest

[AArnott]

The comment about seeing out object was specifically for that API, not this one.

For most cases, including this one, you need to read the API docs to learn what is required. In this case, this is an [Out] void* that receives data based on the second argument.

It looks like you're trying too hard by using IntPtr. IntPtr could be made to work, but it's the harder way:

using System.Runtime.InteropServices;
using Windows.Win32;
using Windows.Win32.Foundation;
using Windows.Win32.Graphics.Dwm;

unsafe static RECT GetExtendedFrameBounds(HWND hwnd)
{
    IntPtr pRect = Marshal.AllocHGlobal(sizeof(RECT));
    try
    {
        PInvoke.DwmGetWindowAttribute(
            hwnd,
            DWMWINDOWATTRIBUTE.DWMWA_EXTENDED_FRAME_BOUNDS,
            pRect.ToPointer(),
            (uint)sizeof(RECT)).ThrowOnFailure();
        return Marshal.PtrToStructure<RECT>(pRect);
    }
    finally
    {
        Marshal.FreeHGlobal(pRect);
    }
}

Note how use of IntPtr requires manually allocating memory, and taking care to free it within a finally to guard against memory leaks.

Here's the easy way:

using Windows.Win32;
using Windows.Win32.Foundation;
using Windows.Win32.Graphics.Dwm;

unsafe static RECT GetExtendedFrameBounds(HWND hwnd)
{
    RECT rect = default;
    PInvoke.DwmGetWindowAttribute(
        hwnd,
        DWMWINDOWATTRIBUTE.DWMWA_EXTENDED_FRAME_BOUNDS,
        &rect,
        (uint)sizeof(RECT)).ThrowOnFailure();
    return rect;
}

See how we don't even need to allocate memory? It's enough that we have a local, and we point to that memory. No memory leak danger, and no try/finally blocks required.
Don't let the unsafe keyword frighten you. In C# when it comes to interop, unsafe code is often easier and therefore safer than manual memory management.