Modify struct layout from p/invoke

Question

I'm looking for best practice guidance around changing the struct/class layout of objects returned/passed into a p/invoke function. I've searched for an answer to this but maybe I'm just too tired and I'm not searching effectively.

The simplest example I can come up with (the real one is a bit too complex for here) is with something like GetWindowRect.

If I wanted to add a few extra properties to the RECT struct, should I just add it to the definition for the struct itself or should I switch over to subclassing to add the extra properties?

Is there a best practice from Microsoft or another reliable source around the following methods? Are both of these against best practice?

[DllImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
static extern bool GetWindowRect(HandleRef hWnd, out RECT lpRect);

[StructLayout(LayoutKind.Sequential)]
public struct RECT
{
    public int Left;        // x position of upper-left corner
    public int Top;         // y position of upper-left corner
    public int Right;       // x position of lower-right corner
    public int Bottom;      // y position of lower-right corner

    public string Extra;    // ADDED
}

Versus

[DllImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
static extern bool GetWindowRect(HandleRef hWnd, out RECT lpRect);

[StructLayout(LayoutKind.Sequential)]
public class RECT
{
    public int Left;        // x position of upper-left corner
    public int Top;         // y position of upper-left corner
    public int Right;       // x position of lower-right corner
    public int Bottom;      // y position of lower-right corner
}

public class RectEx : RECT
{
    public string Extra;    // Added

    public RectEx(RECT r)
    {
        Left = r.Left;
        Top = r.Top;
        Right = r.Right;
        Bottom = r.Bottom;
        Extra = "test";
    }
}

Does the second example work with RECT as a class instead of a struct? — Matthew Layton, Nov 08 '12 at 09:45
You can't use the *out* keyword with a class, that would make it a RECT**, a pointer to a pointer to RECT. The [Out] attribute is required instead. It is certainly best not to monkey with pinvoke types, encapsulate them. — Hans Passant, Nov 08 '12 at 13:30
Good catch on the "out" parameter. Like I said, this is a sample, not an exact duplicate of what I'm doing. The class way would work if it wasn't for the out piece though. Hans, I like your comment though about not monkeying around. — hdrpunk, Nov 08 '12 at 18:03
I've rephrased the question in hopes that it can be reopened. This question is about best practice and specifically if something is meant to be done or not. — hdrpunk, Nov 09 '12 at 15:50

score 1 · Accepted Answer · answered Nov 08 '12 at 09:55

Here is another option: this allows you to maintain native functionality and provides some safety over the objects you are using.

// used internally in native method
[StructLayout(LayoutKind.Sequential)]
internal struct RECT
{
    public int Left;        // x position of upper-left corner
    public int Top;         // y position of upper-left corner
    public int Right;       // x position of lower-right corner
    public int Bottom;      // y position of lower-right corner
}


// public accessible struct with extra fields 
public struct RectEx
{
    public int Left;        // x position of upper-left corner
    public int Top;         // y position of upper-left corner
    public int Right;       // x position of lower-right corner
    public int Bottom;      // y position of lower-right corner

    public dynamic Extra = "Extra";
}


public static class UnsafeNativeMethods
{
    //used internally to populate RECT struct
    [DllImport("user32.dll")]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool GetWindowRect(HandleRef hWnd, out RECT lpRect);

    //public safe method with exception handling and returns a RectEx
    public static RectEx GetWindowRectangle(HandleRef hWnd)
    {
        RECT r = new RECT();
        RectEx result = new RectEx();

        try
        {
            GetWindowRect(hWnd, r);
            result.Left = r.Left;
            result.Top = r.Top;
            result.Right = r.Right;
            result.Bottom = r.Bottom;
            // assign extra fields
        }
        catch(Exception ex)
        {
            // handle ex
        }

    return result;
    }
}

I like what you've suggested, even though it requires some redundancy. Even though I'm not sure this would be the best practice, it seems like a reasonable way to go about things and wanted to give you the points. Thanks! — hdrpunk, Jun 19 '13 at 23:02
@hdrpunk, Yes there is some redundancy here, and since I wrote this I have worked out that you can just add additional fields to the REAL structure (RECT in this instance). You can even have the fields in whatever order suits you, but you will need to use LayoutKind.Explicit so that the marshaller knows where to map the unmanaged data into the correct struct fields. — Matthew Layton, Jun 20 '13 at 08:25

score 0 · Answer 2 · answered Sep 01 '13 at 13:30

You also can use: StructLayout(LayoutKind.Explicit)

[StructLayout(LayoutKind.Sequential)]
public struct Point 
{
   public int x;
   public int y;
}   

[StructLayout(LayoutKind.Explicit)]
public struct Rect 
{
   [FieldOffset(0)] public int left;
   [FieldOffset(4)] public int top;
   [FieldOffset(8)] public int right;
   [FieldOffset(12)] public int bottom;
}

(from http://msdn.microsoft.com/en-us/library/system.runtime.interopservices.layoutkind.aspx)

Modify struct layout from p/invoke

2 Answers2

Linked