12

I'm calling a method via interop that returns an out IntPtr parameter. How can I get a byte* for this IntPtr so I can operate on it? I tried the following:

fixed(byte* ptr = (byte)myIntPtr)

but it didn't work. Any help would be appreciated!

Improve this question
1
  • 1
    Hi Dmitri, could you either request more informations, or accept an answer? Commented Jan 7, 2011 at 12:08

5 Answers 5

Reset to default
20

You can simply write:

byte* ptr = (byte*)int_ptr;

You don't have to use the fixed keyword. You don't want to pin the IntPtr, do you?

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

This also works fine, though personally I like the ToPointer method, especially if you don't need immediately to convert it to a specific type pointer (e.g. from void* to byte*).
9

myIntPtr.ToPointer()

Improve this answer

5 Comments

Note that the fixed keyword isn't really appropiate in this case as it is used to prevent relocation of variables. Since IntPtr is already a (managed) pointer, you essentially just want a direct conversion between the two types. See also msdn.microsoft.com/en-us/library/f58wzh21(VS.71).aspx
IntPtr in this case is not a managed pointer, rather an unmanaged pointer!
Yeah, what I really meant is that IntPtr is a managed pointer in the sense that it's part of the managed libraries, whereas byte* is an unsafe C-style pointer. Perhaps "safe" would be a better word, though it's important to note the difference between IntPtr and SafeHandle.
IntPtr isn't very safe either, seeing as you can cast it from/to integers. Anyway there are lots and lots of legacy APIs to work with, so IntPtr isn't going away anytime soon.
Well yes, it's quite fundamental to Win32 interop programming. I think I made the point the IntPtr isn't very safe (depending on which sense of the word you use) - but at least it does not require an unsafe context as pointers do.
3

I didn't want "unsafe code" in my application, so I did the following to convert an IntPtr to a byte[]. Given an IntPtr called "unsafeDataBlock":

var byteArray = new byte[dataBlockSize];
System.Runtime.InteropServices.Marshal.Copy(unsafeDataBlock, byteArray, 0, dataBlockSize);
Improve this answer

Comments

2

This seemed to work for me, I wasn't using Interop but was still calling a managed C++ function from C Sharp. The managed C++ function however called unmanaged code so it accomplished the same thing as Interop.

Anyway, in the C++ function that was called from c-sharp, I used this code:

(anyPointerType*) pointer = (anyPointertype*) myIntPtr.ToPointer();
Improve this answer

1 Comment

Just to clarify what I meant by: " I wasn't using Interop but was still calling a managed C++ function from C Sharp. The managed C++ function however called unmanaged code so it accomplished the same thing as Interop. " calling unmanged code through Interop: C-Sharp -(Using Interop calls)> unmanaged code has the same result as calling from c-sharp a managed c++ function that calls unmanaged code: C-Sharp -(Calls)> Managed C++ function -(Calls)> unmanaged code and the latter procedure is usually much easier
1

If you don't want unsafe code in your application, you'll have to use the methods in System.Runtime.InteropServices.Marshal, or (even better) declare your interop functions' parameter types so the marshaling happens automatically.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.