Я пытаюсь обработать сообщение WM_MOUSEMOVE в С#.
Каков правильный способ получить координату X и Y из lParam, которая является типом IntPtr?
Выиграйте api в С#. Получить привет и низкое слово из IntPtr
Ответ 1
Try:
(обратите внимание, что это была начальная версия, читаемая ниже для окончательной версии)
IntPtr xy = value;
int x = unchecked((short)xy);
int y = unchecked((short)((uint)xy >> 16));
unchecked обычно не требуется (потому что "невыполненные" проекты С# не отмечены)
Учтите, что это определения используемых макросов:
#define LOWORD(l) ((WORD)(((DWORD_PTR)(l)) & 0xffff))
#define HIWORD(l) ((WORD)((((DWORD_PTR)(l)) >> 16) & 0xffff))
#define GET_X_LPARAM(lp) ((int)(short)LOWORD(lp))
#define GET_Y_LPARAM(lp) ((int)(short)HIWORD(lp))
Где WORD == ushort, DWORD == uint. Я сокращаю некоторые сокращенные преобразования.
Добавление:
через полтора года, и, испытав "капризы" из 64 бит .NET, я согласен с Celess (но обратите внимание, что 99% сообщений Windows по-прежнему составляют 32 бита по соображениям совместимости, поэтому я не подумайте, что сейчас проблема не такая большая. Это больше для будущего, и потому, что если вы хотите что-то сделать, вы должны сделать это правильно.)
Единственное, что я хотел бы сделать, это следующее:
IntPtr xy = value;
int x = unchecked((short)(long)xy);
int y = unchecked((short)((long)xy >> 16));
вместо того, чтобы делать проверку "это IntPtr 4 или 8 байтов длиной", я беру наихудший случай (длиной 8 байтов) и отбрасывает xy на long. С небольшим ударом двойной компилятор (до long, а затем до short/to uint) будет оптимизирован компилятором (в итоге явное преобразование в int of IntPtr является красной селедкой... Если вы используете его, вы рискуете в будущем. Вы всегда должны использовать преобразование long, а затем использовать его напрямую/повторно использовать его для того, что вам нужно, показывая будущим программистам, что вы знали, что вы делали.
Пример теста: http://ideone.com/a4oGW2 (к сожалению, всего 32 бита, но если у вас есть 64-разрядная машина, вы можете протестировать один и тот же код)
Ответ 2
Корректно для 32 и 64-битных:
Point GetPoint(IntPtr _xy)
{
uint xy = unchecked(IntPtr.Size == 8 ? (uint)_xy.ToInt64() : (uint)_xy.ToInt32());
int x = unchecked((short)xy);
int y = unchecked((short)(xy >> 16));
return new Point(x, y);
}
- или -
int GetIntUnchecked(IntPtr value)
{
return IntPtr.Size == 8 ? unchecked((int)value.ToInt64()) : value.ToInt32();
}
int Low16(IntPtr value)
{
return unchecked((short)GetIntUnchecked(value));
}
int High16(IntPtr value)
{
return unchecked((short)(((uint)GetIntUnchecked(value)) >> 16));
}
Они также работают:
int Low16(IntPtr value)
{
return unchecked((short)(uint)value); // classic unchecked cast to uint
}
int High16(IntPtr value)
{
return unchecked((short)((uint)value >> 16));
}
- или -
int Low16(IntPtr value)
{
return unchecked((short)(long)value); // presumption about internals
} // is what framework lib uses
int High16(IntPtr value)
{
return unchecked((short)((long)value >> 16));
}
Идет другим путем
public static IntPtr GetLParam(Point point)
{
return (IntPtr)((point.Y << 16) | (point.X & 0xffff));
} // mask ~= unchecked((int)(short)x)
- или -
public static IntPtr MakeLParam(int low, int high)
{
return (IntPtr)((high << 16) | (low & 0xffff));
} // (IntPtr)x is same as 'new IntPtr(x)'
Принятый ответ - хороший перевод определения C. Если бы вы имели дело только с сырым "void *", то это было бы в основном нормально. Однако при использовании "IntPtr" в 64-битной среде исполнения .Net "unchecked" не останавливает исключения переполнения конверсий изнутри IntPtr. Непроверенный блок не влияет на конверсии, которые происходят внутри функций и операторов IntPtr. В настоящее время принятый ответ гласит, что использование "непроверенного" не требуется. Однако использование "unchecked" абсолютно необходимо, как это всегда бывает при отбрасывании отрицательных значений из более крупного типа.
В 64-битном из принятого ответа:
var xy = new IntPtr(0x0FFFFFFFFFFFFFFF);
int x = unchecked((short)xy); // <-- throws
int y = unchecked((short)((uint)xy >> 16)); // gets lucky, 'uint' implicit 'long'
y = unchecked((short)((int)xy >> 16)); // <-- throws
xy = new IntPtr(0x00000000FFFF0000); // 0, -1
x = unchecked((short)xy); // <-- throws
y = unchecked((short)((uint)xy >> 16)); // still lucky
y = (short)((uint)xy >> 16); // <-- throws (short), no longer lucky
В 64-разрядной версии, используя экстраполированную версию DmitryG's:
var ptr = new IntPtr(0x0FFFFFFFFFFFFFFF);
var xy = IntPtr.Size == 8 ? (int)ptr.ToInt64() : ptr.ToInt32(); // <-- throws (int)
int x = unchecked((short)xy); // fine, if gets this far
int y = unchecked((short)((uint)xy >> 16)); // fine, if gets this far
y = unchecked((short)(xy >> 16)); // also fine, if gets this far
ptr = new IntPtr(0x00000000FFFF0000); // 0, -1
xy = IntPtr.Size == 8 ? (int)ptr.ToInt64() : ptr.ToInt32(); // <-- throws (int)
По производительности
return IntPtr.Size == 8 ? unchecked((int)value.ToInt64()) : value.ToInt32();
Свойство IntPtr.Size возвращает константу как литерал времени компиляции, который способен, будучи встроенным в сборку. Таким образом, для JIT возможно почти все это оптимизировано. Также можно сделать:
return unchecked((int)value.ToInt64());
- или -
return unchecked((int)(long)value);
- или -
return unchecked((uint)value); // traditional
и все три из них всегда будут вызывать эквивалент IntPtr.ToInt64(). ToInt64() и "operator long" также могут быть встроены, но с меньшей вероятностью. Это гораздо больше кода в 32-разрядной версии, чем константа размера. Я бы сказал, что решение наверху, возможно, более симпатично правильно. Его также важно знать о артефактах расширений знака, которые заполняли бы все 64-битные ошибки без изменений на что-то вроде (long) int_val, хотя я в значительной степени замалчивался над этим здесь, однако может дополнительно влиять на inlining на 32-разрядной версии.
Useage
if (Low16(wParam) == NativeMethods.WM_CREATE)) { }
var x = Low16(lParam);
var point = GetPoint(lParam);
"Безопасный" макет IntPtr, показанный ниже для будущих трейдеров.
Запустите этот без, чтобы установить WIN32 на 32-битной основе, чтобы получить сильное моделирование 64-битного поведения IntPtr.
public struct IntPtrMock
{
#if WIN32
int m_value;
#else
long m_value;
#endif
int IntPtr_ToInt32() {
#if WIN32
return (int)m_value;
#else
long l = m_value;
return checked((int)l);
#endif
}
public static explicit operator int(IntPtrMock value) { //(short) resolves here
#if WIN32
return (int)value.m_value;
#else
long l = value.m_value;
return checked((int)l); // throws here if any high 32 bits
#endif // check forces sign stay signed
}
public static explicit operator long(IntPtrMock value) { //(uint) resolves here
#if WIN32
return (long)(int)value.m_value;
#else
return (long)value.m_value;
#endif
}
public int ToInt32() {
#if WIN32
return (int)value.m_value;
#else
long l = m_value;
return checked((int)l); // throws here if any high 32 bits
#endif // check forces sign stay signed
}
public long ToInt64() {
#if WIN32
return (long)(int)m_value;
#else
return (long)m_value;
#endif
}
public IntPtrMock(long value) {
#if WIN32
m_value = checked((int)value);
#else
m_value = value;
#endif
}
}
public static IntPtr MAKELPARAM(int low, int high)
{
return (IntPtr)((high << 16) | (low & 0xffff));
}
public Main()
{
var xy = new IntPtrMock(0x0FFFFFFFFFFFFFFF); // simulate 64-bit, overflow smaller
int x = unchecked((short)xy); // <-- throws
int y = unchecked((short)((uint)xy >> 16)); // got lucky, 'uint' implicit 'long'
y = unchecked((short)((int)xy >> 16)); // <-- throws
int xy2 = IntPtr.Size == 8 ? (int)xy.ToInt64() : xy.ToInt32(); // <-- throws
int xy3 = unchecked(IntPtr.Size == 8 ? (int)xy.ToInt64() : xy.ToInt32()); //ok
// proper 32-bit lParam, overflow signed
var xy4 = new IntPtrMock(0x00000000FFFFFFFF); // x = -1, y = -1
int x2 = unchecked((short)xy4); // <-- throws
int xy5 = IntPtr.Size == 8 ? (int)xy4.ToInt64() : xy4.ToInt32(); // <-- throws
var xy6 = new IntPtrMock(0x00000000FFFF0000); // x = 0, y = -1
int x3 = unchecked((short)xy6); // <-- throws
int xy7 = IntPtr.Size == 8 ? (int)xy6.ToInt64() : xy6.ToInt32(); // <-- throws
var xy8 = MAKELPARAM(-1, -1); // WinForms macro
int x4 = unchecked((short)xy8); // <-- throws
int xy9 = IntPtr.Size == 8 ? (int)xy8.ToInt64() : xy8.ToInt32(); // <-- throws
}
Ответ 3
Обычно для обработки мыши на нижнем уровне я использовал следующий помощник (он также считает, что размер IntPtr зависит от x86/x64):
//...
Point point = WinAPIHelper.GetPoint(msg.LParam);
//...
static class WinAPIHelper {
public static Point GetPoint(IntPtr lParam) {
return new Point(GetInt(lParam));
}
public static MouseButtons GetButtons(IntPtr wParam) {
MouseButtons buttons = MouseButtons.None;
int btns = GetInt(wParam);
if((btns & MK_LBUTTON) != 0) buttons |= MouseButtons.Left;
if((btns & MK_RBUTTON) != 0) buttons |= MouseButtons.Right;
return buttons;
}
static int GetInt(IntPtr ptr) {
return IntPtr.Size == 8 ? unchecked((int)ptr.ToInt64()) : ptr.ToInt32();
}
const int MK_LBUTTON = 1;
const int MK_RBUTTON = 2;
}