Gagner de l'api en C#. Obtenir haut et bas mot à partir de IntPtr

Corriger à la fois 32 et 64 bits:

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);
}

- ou -

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));
}

Ces travaux:

int Low16(IntPtr value)
{
    return unchecked((short)(uint)value);   //classic unchecked cast to uint
}
int High16(IntPtr value)
{
    return unchecked((short)((uint)value >> 16));
}

- ou -

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));
}

Autre

public static IntPtr GetLParam(Point point)
{
    return (IntPtr)((point.Y << 16) | (point.X & 0xffff));
}                                           //mask ~= unchecked((int)(short)x)

- ou -

public static IntPtr MakeLParam(int low, int high)
{
    return (IntPtr)((high << 16) | (low & 0xffff));  
}                                           //(IntPtr)x is same as 'new IntPtr(x)'

Accepté la réponse est bonne traduction de la C de la définition. Si traitent seulement la première 'void*' directement, serait alors la plupart du temps correct. Cependant lors de l'utilisation de 'IntPtr" dans un .Net 64 bits de l'environnement d'exécution, 'non cochée" ne va pas arrêter la conversion des exceptions de dépassement d'être expulsé de l'intérieur IntPtr. La décoché bloc ne pas affecter les conversions qui se produisent à l'intérieur de IntPtr funcitons et les opérateurs. Actuellement la accepté de répondre stipule que l'utilisation de "unchecked" n'est pas nécessaire. Cependant, l'utilisation de "décochées" est absolument nécessaire, comme ce serait toujours le cas dans un casting pour les valeurs négatives d'un grand type.

Sur 64-bit, de la accepté de répondre:

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  

Sur 64 bits, en utilisant la version extrapolée de DmitryG de l':

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)

Sur la performance

return IntPtr.Size == 8 ? unchecked((int)value.ToInt64()) : value.ToInt32();

La IntPtr.La taille de la propriété renvoie une constante de temps de compilation littéral qui est capable si être insérée à travers des assemblées. Est donc possible pour l'équipe d'avoir quasi-totalité de cette optimisé à. Pourrait également le faire:

return unchecked((int)value.ToInt64());

- ou -

return unchecked((int)(long)value);

- ou -

return unchecked((uint)value);           //traditional

et tous les 3 de ces sera toujours appeler le equivalient de IntPtr.ToInt64(). ToInt64(), et " opérateur de long, sont également susceptibles d'être intégrées, mais moins susceptibles de l'être. Est beaucoup plus de code en version 32 bits que la Taille de la constante. Je dirais que la solution au dessus n'est peut-être plus symantically correcte. Il est aussi important d'être conscient de connexion extension des artefacts, ce qui permettrait de combler tous les 64-bits reguardless sur quelque chose comme (long)int_val, bien que j'ai assez bien dissimulée qu'ici, cependant, peut en outre affecter inline sur 32 bits.

Useage

if (Low16(wParam) == NativeMethods.WM_CREATE)) { }

var x = Low16(lParam);

var point = GetPoint(lParam);

---

Sûre IntPtr maquette indiqué ci-dessous pour les futurs traverlers.

Exécuter ce sans réglage de la WIN32 définir sur 32 bits pour obtenir une simulation solide de la 64 bits IntPtr comportements.

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
}