What is void* in C#? [duplicate]

Answer 1

Void is actually nothing,

there are three ways of using void:

• argument: int myFunc(void) -- the function takes nothing.

• return value: void myFunc(int) -- the function returns nothing

• Generic data pointer: void* data -- 'data' is a pointer to data of unknown type, and cannot be dereferenced

In this case its a Generic data pointer.

Answer 2

void* is a pointer to an object of undefined type. There are various representations for this in C#:

1. As an unformatted pointer in unsafe code.
2. As an IntPtr, that is typically used for marshalling pointers between managed and unmanaged objects.
3. As object for unspecified, but managed objects.

Answer 3

In general, void* would be converted to IntPtr in C# code.

Edit with a bit more information: IntPtr in .NET/C# often behaves like an opaque handle. You can't directly dereference it, obtain "size" information from it (e.g. the size of an array you're pointing at), and it doesn't try to tell you what data type it's pointing at - or even if it's a pointer at all. When you are translating C/C++ code to C# and you see void*, the C# code should be written with IntPtr until you have a better idea what exactly you're dealing with.

The pinvoke.net site has two entries for glTexImage2D, depending on where the image data is stored. If the image data is stored in a managed byte[] in .NET/C#, you call the version that passes a byte[]. If the image data is stored in unmanaged memory and you only have an IntPtr to the data in the C# code, you call the version that passes an IntPtr.

Examples from pinvoke.net opengl32:

[DllImport(LIBRARY_OPENGL)] protected static extern void glTexImage2D (
    uint target,
    int level, 
    int internalformat, 
    int width, 
    int height, 
    int border, 
    uint format, 
    uint type, 
    byte[] pixels);
[DllImport(LIBRARY_OPENGL)] protected static extern void glTexImage2D (
    uint target, 
    int level, 
    int internalformat, 
    int width, 
    int height, 
    int border, 
    uint format, 
    uint type, 
    IntPtr pixels);

Answer 4

it's casting imageData to the type (void*), so basically telling the compiler to take this value and treat it as though it were a (void*)

from my experience, void* is a pointer to a non-specific type.

---

As far as converting your example to c#, then you don't really have to worry too much about how things are being cast in the c++. Just make sure that you're passing the right types into the corresponding c# function.

Answer 5

It's most typically an IntPtr in C#.

Here is an example of how to call this function from C#:

Bitmap bitmap = new Bitmap("blah");
Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, 4, bitmap.Width, bitmap.Height, 0, Gl.GL_RGBA, Gl.GL_UNSIGNED_BYTE, bitmap.Scan0);

if(bitmap != null) {
    bitmap.Dispose();
}

Source: http://www.gamedev.net/topic/193827-how-to-use-glglteximage2d--using-csgl-library-in-c/

And if what you have is a byte[] that contains a valid image, you can load it into a bitmap as such:

public static Bitmap BytesToBitmap(byte[] byteArray)
{
    using (MemoryStream ms = new MemoryStream(byteArray))
    {
        Bitmap img = (Bitmap)Image.FromStream(ms);
        return img;
    }
}

If that gives you trouble, or your data is not something that the Win32 libs can handle, you can use Marshal to give you an IntPtr from a byte[] directly.

IntPtr unmanagedPointer = Marshal.AllocHGlobal(bytes.Length);
Marshal.Copy(bytes, 0, unmanagedPointer, bytes.Length);

// Call your function here, passing unmanagedPointer to it

Marshal.FreeHGlobal(unmanagedPointer);

From: How to get IntPtr from byte[] in C#

Answer 6

As already said IntPtr is the equivalent.

You can use pointers only in unsafe context in c#, e.g.:

void MyMethod(IntPtr ptr)
{
  unsafe
  {
      var vptr = (void*) ptr;
      // do something with the void pointer
  }
}