Three Ways to Marshal Data - Which is best?

[O.B.]

I have operation within a class that marshals the data into a byte
array. Below are three different ways that work. Are there any
downsides to using one over the the other?

public virtual byte[] ToRaw1()
{
byte[] byteArray = new byte[Size];
IntPtr pointer = Marshal.AllocHG lobal(Size);
Marshal.Structu reToPtr(this, pointer, false);
Marshal.Copy(po inter, byteArray, 0, Size);
Marshal.FreeHGl obal(pointer);
return byteArray;
}

public virtual byte[] ToRaw2()
{
byte[] byteArray = new byte[Size];
IntPtr byteArrayPtr = Marshal.UnsafeA ddrOfPinnedArra yElement
(byteArray, 0);
Marshal.Structu reToPtr(this, byteArrayPtr, false);
return byteArray;
}

public virtual byte[] ToRaw3()
{
byte[] byteArray = new byte[Size];
unsafe
{
fixed (byte* pData = byteArray)
{
Marshal.Structu reToPtr(this, (IntPtr)pData, false);
}
}
return byteArray;
}

[Nicholas Paldino [.NET/C# MVP]]

Well, #2 is incorrect in that you aren't pinning the array before
passing it to UnsafeAddrOfPin nedArrayElement .

#1 is going to leak memory if an exception is thrown before the call to
FreeHGlobal.

Generally though, I would say not to use any of these. You should use
Serialization or DataContracts instead. You are marshalling in .NET, not to
unmanaged code (else, why have the byte array) and you want to go from .NET
to .NET, not from .NET to unmanaged code.

Otherwise, why have it in a byte array?

--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"O.B." <fu******@bells outh.netwrote in message
news:f3******** *************** ***********@l33 g2000pri.google groups.com...

>I have operation within a class that marshals the data into a byte
array. Below are three different ways that work. Are there any
downsides to using one over the the other?

public virtual byte[] ToRaw1()
{
byte[] byteArray = new byte[Size];
IntPtr pointer = Marshal.AllocHG lobal(Size);
Marshal.Structu reToPtr(this, pointer, false);
Marshal.Copy(po inter, byteArray, 0, Size);
Marshal.FreeHGl obal(pointer);
return byteArray;
}

public virtual byte[] ToRaw2()
{
byte[] byteArray = new byte[Size];
IntPtr byteArrayPtr = Marshal.UnsafeA ddrOfPinnedArra yElement
(byteArray, 0);
Marshal.Structu reToPtr(this, byteArrayPtr, false);
return byteArray;
}

public virtual byte[] ToRaw3()
{
byte[] byteArray = new byte[Size];
unsafe
{
fixed (byte* pData = byteArray)
{
Marshal.Structu reToPtr(this, (IntPtr)pData, false);
}
}
return byteArray;
}

[O.B.]

Good call on #1. #3 is also seems to better than #1 in that it
doesn't allocate an additional buffer of memory.

I've corrected #2 as follows to pin the address first.
public virtual byte[] ToRaw2()
{
byte[] byteArray = new byte[Size];
GCHandle byteArrayPtr = GCHandle.Alloc( byteArray,
GCHandleType.Pi nned);
Marshal.Structu reToPtr(this, byteArrayPtr.Ad drOfPinnedObjec t(),
false);
return byteArray;
}

However, I can't determine if #2 or #3 is better. Thoughts?

As for converting the data to a byte array, I have a structure that
serves as a generic data handler between our application and other
applications. This structure has the smarts to determine whether the
data is to be sent through an Internet socket, a COM object, or
another .NET application). To keep it generic, the interface requires
a byte array of the data being sent and received. In addition, the
data conversion to a byte array must be as fast as possible, so as to
maintain real-time operation. It has been my observation that
Marshal.Structu reToPtr is faster than manually marshaling the data
into a byte array.

On Nov 12, 1:06*pm, "Nicholas Paldino [.NET/C# MVP]"
<[e-mail] d.caspershouse. comwrote:

* * Well, #2 is incorrect in that you aren't pinning the array before
passing it to UnsafeAddrOfPin nedArrayElement .

* * #1 is going to leak memory if an exception is thrown before the call to
FreeHGlobal.

* * Generally though, I would say not to use any of these. *You should use
Serialization or DataContracts instead. *You are marshalling in .NET, not to
unmanaged code (else, why have the byte array) and you want to go from .NET
to .NET, not from .NET to unmanaged code.

* * Otherwise, why have it in a byte array?

--
* * * * * - Nicholas Paldino [.NET/C# MVP]
* * * * * - [e-mail] .caspershouse.c om

"O.B." <funkj...@bells outh.netwrote in message

news:f3******** *************** ***********@l33 g2000pri.google groups.com...

I have operation within a class that marshals the data into a byte
array. *Below are three different ways that work. *Are there any
downsides to using one over the the other?

public virtual byte[] ToRaw1()
{
*byte[] byteArray = new byte[Size];
*IntPtr pointer = Marshal.AllocHG lobal(Size);
*Marshal.Struct ureToPtr(this, pointer, false);
*Marshal.Copy(p ointer, byteArray, 0, Size);
*Marshal.FreeHG lobal(pointer);
*return byteArray;
}

public virtual byte[] ToRaw2()
{
*byte[] byteArray = new byte[Size];
*IntPtr byteArrayPtr = Marshal.UnsafeA ddrOfPinnedArra yElement
(byteArray, 0);
*Marshal.Struct ureToPtr(this, byteArrayPtr, false);
*return byteArray;
}

public virtual byte[] ToRaw3()
{
*byte[] byteArray = new byte[Size];
*unsafe
*{
* *fixed (byte* pData = byteArray)
* *{
* * *Marshal.Struct ureToPtr(this, (IntPtr)pData, false);
* *}
*}
*return byteArray;
}