CODEWITHSUNDEEP
c#arrays
Nefzen
Nefzen

Reputation: 7929

how to convert a value type to byte[] in C#?

I want to do the equivalent of this:

byte[] byteArray;
enum commands : byte {one, two};
commands content = one;
byteArray = (byte*)&content;

yes, it's a byte now, but consider I want to change it in the future? how do I make byteArray contain content? (I don't care to copy it).

Upvotes: 10

Views: 15677

Answers (5)

Sardelka
Sardelka

Reputation: 483

Here is a generic and unsafe variant if you care about performance and don't want to mess with GC

        static unsafe void StructToByteArr<T>(ref T obj, Span<byte> dest) where T : unmanaged
        {
            fixed (void* pSrc = &obj, pDest = dest)
            {
                Buffer.MemoryCopy(pSrc, pDest, dest.Length, sizeof(T));
            }
        }
        static unsafe void StructToByteArr<T>(ref T obj, byte[] dest, int destOffset) where T : unmanaged
        {
            StructToByteArr(ref obj, new Span<byte>(dest, destOffset, sizeof(T)));
        }

        static unsafe byte[] StructToByteArr<T>(ref T obj) where T : unmanaged
        {
            var result = new byte[sizeof(T)];
            StructToByteArr(ref obj, result, 0);
            return result;
        }

You can remove ref if you're passing a struct smaller than the size of a pointer.

Upvotes: 1

Rob Sanders
Rob Sanders

Reputation: 5347

For anyone who's interested in how it works without using BitConverter you can do it like this:

// Convert double to byte[]
public unsafe byte[] pack(double d) {
    byte[] packed = new byte[8]; // There are 8 bytes in a double
    void* ptr = &d; // Get a reference to the memory containing the double
    for (int i = 0; i < 8; i++) { // Each one of the 8 bytes needs to be added to the byte array
        packed[i] = (byte)(*(UInt64 *)ptr >> (8 * i)); // Bit shift so that each chunk of 8 bits (1 byte) is cast as a byte and added to array 
    }
    return packed;
}

// Convert byte[] to double
public unsafe double unpackDouble(byte[] data) {
    double unpacked = 0.0; // Prepare a chunk of memory ready for the double
    void* ptr = &unpacked; // Reference the double memory
    for (int i = 0; i < data.Length; i++) {
        *(UInt64 *)ptr |= ((UInt64)data[i] << (8 * i)); // Get the bits into the right place and OR into the double
    }
    return unpacked;
}

In reality it's much easier and safer to use BitConverter but it's fun to know!

Upvotes: 5

OregonGhost
OregonGhost

Reputation: 23759

To convert any value types (not just primitive types) to byte arrays and vice versa:

    public T FromByteArray<T>(byte[] rawValue)
    {
        GCHandle handle = GCHandle.Alloc(rawValue, GCHandleType.Pinned);
        T structure = (T)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(T));
        handle.Free();
        return structure;
    }

    public byte[] ToByteArray(object value, int maxLength)
    {
        int rawsize = Marshal.SizeOf(value);
        byte[] rawdata = new byte[rawsize];
        GCHandle handle =
            GCHandle.Alloc(rawdata,
            GCHandleType.Pinned);
        Marshal.StructureToPtr(value,
            handle.AddrOfPinnedObject(),
            false);
        handle.Free();
        if (maxLength < rawdata.Length) {
            byte[] temp = new byte[maxLength];
            Array.Copy(rawdata, temp, maxLength);
            return temp;
        } else {
            return rawdata;
        }
    }

Upvotes: 21

J&#248;rn Schou-Rode
J&#248;rn Schou-Rode

Reputation: 38336

The BitConverter class might be what you are looking for. Example:

int input = 123;
byte[] output = BitConverter.GetBytes(input);

If your enum was known to be an Int32 derived type, you could simply cast its values first:

BitConverter.GetBytes((int)commands.one);

Upvotes: 17

Sean
Sean

Reputation: 62492

You can use the BitConverter.GetBytes method to do this.

Upvotes: 3

Related Questions