C# how to get Byte[] from IntPtr

I have a .dll(not my own) that has a delegate. This delegate Callback function is:
"CallBackFN(ushort opCOde, IntPtr payload, uint size, uint localIP)"

How can i convert IntPtr to Byte[]? I think that payload is actually Byte[]. If it's not Byte[] and it's something else would i lose some data?

If it's a byte[] array:

 byte[] managedArray = new byte[size];
 Marshal.Copy(pnt, managedArray, 0, size);

If it's not byte[], the size parameter in of Marshal.Copy is the number of elements in the array, not the byte size. So, if you had an int[] array rather than a byte[] array, you would have to divide by 4 (bytes per int) to get the correct number of elements to copy, assuming your size parameter passed through the callback refers to the number of bytes.

Have you looked into Marshal.Copy?

http://msdn.microsoft.com/en-us/library/system.runtime.interopservices.marshal.copy.aspx

If you need performance, use it directly:

unsafe { 
	byte *ptr = (byte *)buffer.ToPointer();

	int offset = 0;
	for (int i=0; i<height; i++)
	{
		for (int j=0; j<width; j++)
		{
	
			float b = (float)ptr[offset+0] / 255.0f;
			float g = (float)ptr[offset+1] / 255.0f;
			float r = (float)ptr[offset+2] / 255.0f;
			float a = (float)ptr[offset+3] / 255.0f;
			offset += 4;
	
			UnityEngine.Color color = new UnityEngine.Color(r, g, b, a);
			texture.SetPixel(j, height-i, color);
		}
	}
}

According to this Stack Overflow question, you can do the following:

var byteArray = new byte[dataBlockSize];
System.Runtime.InteropServices.Marshal.Copy(payload, byteArray, 0, dataBlockSize);

Span<byte> may be a better solution as it provides most features you need from a byte array. It is faster as you won't need to allocate and copy to a new buffer and safer as you will not have to use directly the pointer.

IntPtr ptr = ... ; 
int ptrLength = ...; 


unsafe
{
    Span<byte> byteArray = new Span<byte>(ptr.ToPointer(), ptrLength);

    for (int i = 0; i < byteArray.Length; i++ )
    {
        // Use it as normalarray array ;
        byteArray[i] = 6;
    }

    // You can always get a byte array . Caution, it allocates a new buffer
    byte[] realByteArray = byteArray.ToArray();
}

It's included in.NET Core 2.1 and a nuget package (System.Memory) for .NET Framework 4.5 + and .NET Core 2.0 +;

You can use Marshal.Copy Method (IntPtr, Byte[], Int32, Int32)