[API Addition] Message.GetLParam<T>()

[hughbe]

We currently have

public class Message
{
        // ..
        public object GetLParam(Type cls) => Marshal.PtrToStructure(LParam, cls);
        // ..
}

However, this is implemented using Marshal.PtrToStructure which has been obsoleted. I propose adding a new API that uses the un-obsoleted marshal API:

public class Message
{
        // ..
        public T GetLParam<T>() => Marshal.PtrToStructure<T>(LParam);
        // ..
}

This would avoid the need for all the casting, e.g

NativeMethods.NMHDR nmhdr = (NativeMethods.NMHDR)m.GetLParam(typeof(NativeMethods.NMHDR));

[zsd4yr]

How many instances would be affected by this change?

Are you proposing we add this API to message in additional to the obsolete one or instead of the obsolete one? If you are proposing the latter, how would other people porting their apps detect this breaking change?

[sharwell]

If possible (i.e. if T is blittable), it would be more efficient to implement this as returning ref readonly T.

[hughbe]

So this API addition would be strictly non-breaking to existing users - although we may choose to obsolete the old api that’s a decision to be make by others.

@sharwell How do we marshal an IntPtr to a blittable struct? Do we just call ToPointer then do some unsafe sorcery?

[sharwell]

public static ref readonly T GetParam<T>(IntPtr ptr)
    where T : unmanaged
{
    unsafe
    {
        return ref *(T*)ptr;
    }
}

[hughbe]

Nice - will bear that in mind!

However, I'm not sure if we can have the following APIs?

public class Message
{
        // ..
        public object GetLParam<T>() => Marshal.PtrToStructure<T>(LParam);
        public ref readonly T GetParam<T>() where T :unmanaged
        {
            unsafe
            {
                return ref *(T*)ptr;
            }
        }
}

Sadly APIs can't differ by return type or constraints

[weltkante]

You probably want to return T and not object in the first case, to avoid boxing the struct? Marshal.PtrToStructure<T> doesn't return object either.

Also it's probably a typo, but you gave them different names.

[sharwell]

For my local experiments, I used three methods:

T GetLParam<T>();
ref T GetLParamRef<T>() where T : unmanaged;
ref readonly T GetLParamRefReadonly<T>() where T : unmanaged;

The third is most efficient and works in most cases. The second is just as efficient as the third, but allows the caller to write to the value, which may not always be correct. Technically the caller of the second can assign the result to a ref readonly local, so we could probably get away with just the first two.

[hughbe]

@sharwell do you reckon that something like this could be a useful addition to the Marshal class itself?

.. ref Marshal.PtrToStructureRef<T>

etc.

[zsd4yr]

#835 is adding these as internal to get the benefits. We should consider this API change.