IntPtr on a 32-bit OS and UInt64 on a 64-bit OS

Question

I'm trying to do an interop to a C++ structure from C#. The structure (in a C# wrapper) is something like this

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public struct SENSE4_CONTEXT
{
    public System.IntPtr dwIndex; // Or UInt64, depending on platform.
}

The underlying C++ structure is a bit abnormal. On a 32-bit OS, dwIndex must be IntPtr in order for the interop to work, but on a 64-bit OS, it must be UInt64 in order for the interop to work.

How can I modify the above structure to make it work on both a 32-bit and 64-bit OS?

Are you talking about the *operating system*, regardless of whether you're running in WOW64 or not? Because in a 32-bit process, `IntPtr` will be 32-bit and 64-bit in a 64-bit process... — Dean Harding, May 17 '10 at 04:30
@codeka, I'm talking about 32 or 64 bit *process*. I want to run as 32 bit process on 32 bit OS, and 64 bit process on 64 bit OS. — Graviton, May 17 '10 at 04:38

score 1 · Answer 1 · answered May 17 '10 at 04:29

1

In a 64-bit process, an IntPtr should be marshalled exactly the same as a UInt64.
Make sure to set your Target Platform to Any CPU.

To treat it as a UInt64 in C#, you can write

UInt64 value = (UInt64)s.dwIndex.ToInt64();

If you need to run as a 32-bit process, you'll need to declare two different versions of the struct, and two different overloads of the methods that take it, and select one of them using an if statement.

answered May 17 '10 at 04:29

SLaks

868,454
176
1,908
1,964

That's the problem; an `IntPtr` should be marshalled as `UInt64`, but it's not. – Graviton May 17 '10 at 04:30
1

What's the difference? They're both eight bytes. – SLaks May 17 '10 at 04:30
Do you mean it needs to be unsigned? In that case, you can use `UIntPtr`: http://msdn.microsoft.com/en-us/library/system.uintptr%28v=VS.71%29.aspx – Dean Harding May 17 '10 at 04:31
@SLaks, there should be no difference. But I don't know why I got such a problem. – Graviton May 17 '10 at 04:33
What *is* the problem exactly? – Dean Harding May 17 '10 at 04:34
1

SLaks is correct. To interop there is no difference between a UInt64 and an IntPtr on a 64 bit process. – Josh May 17 '10 at 04:36
@SLaks, the difference is that if you use `IntPtr` in place of `UInt64`, the code might fail to run. – Graviton May 17 '10 at 06:17
@Ngu: That does not make sense. Do you know how it is passed differently or how it fails? – SLaks May 17 '10 at 12:29
@SLaks, I don't, partly because I don't have access to the underlying C++ code. – Graviton May 18 '10 at 04:15

EMP · Accepted Answer · 2010-05-17T04:49:11.203

1

If the "dw" prefix in dwIndex is accurate then it sounds like a DWORD, which is a 32-bit unsigned integer. In that case you need to use UIntPtr, which will be like UInt32 on 32-bit and like UInt64 on 64-bit.

It seems unlikely that your C++ program requires a signed integer on a 32-bit platform and an unsigned one on a 64-bit one (though not impossible, of course).

edited May 17 '10 at 04:49

answered May 17 '10 at 04:34

EMP

59,148
53
164
220

A `DWORD` type is a 32-bit unsigned integer regardless of whether or not the OS is 32 or 64 bit. – JaredPar May 17 '10 at 06:31

score 0 · Answer 3 · answered May 17 '10 at 04:29

0

You could use a compiler directive/platform detect, then do a common typedef:

typedef indexType IntPtr

or

typedef indexType UInt64

answered May 17 '10 at 04:29

Delan Azabani

79,602
28
170
210

IntPtr on a 32-bit OS and UInt64 on a 64-bit OS

3 Answers3

Linked