reinterpret_cast in C#

Question

I'm looking for a way to reinterpret an array of type byte[] as a different type, say short[]. In C++ this would be achieved by a simple cast but in C# I haven't found a way to achieve this without resorting to duplicating the entire buffer.

Any ideas?

Answer 1

You can use System.Memory to do this in a safe way.

public static TTo[] Cast<TFrom, TTo>(this TFrom[] source) where TTo : struct where TFrom : struct => 
  MemoryMarshal.Cast<TFrom, TTo>(source).ToArray();

private byte[] CastToBytes(int[] foo) => foo.Cast<int, byte>(foo);

Answer 2

There are four good answers to this question. Each has different downsides. Of course, beware of endianness and realize that all of these answers are holes in the type system, just not particularly treacherous holes. In short, don't do this a lot, and only when you really need to.

1. Sander's answer. Use unsafe code to reinterpret pointers. This is the fastest solution, but it uses unsafe code. Not always an option.

2. Leonidas' answer. Use StructLayout and FieldOffset(0) to turn a struct into a union. The downsides to this are that some (rare) environments don't support StructLayout (eg Flash builds in Unity3D) and that StructLayout cannot be used with generics.

3. ljs' answer. Use BitConverter methods. This has the disadvantage that most of the methods allocate memory, which isn't great in low-level code. Also, there isn't a full suite of these methods, so you can't really use it generically.

4. Buffer.BlockCopy two arrays of different types. The only downside is that you need two buffers, which is perfect when converting arrays, but a pain when casting a single value. Just beware that length is specified in bytes, not elements. Buffer.ByteLength helps. Also, it only works on primitives, like ints, floats and bools, not structs or enums.

But you can do some neat stuff with it.

public static class Cast {

    private static class ThreadLocalType<T> {

        [ThreadStatic]
        private static T[] buffer;

        public static T[] Buffer
        {
            get
            {
                if (buffer == null) {
                    buffer = new T[1];
                }
                return buffer;
            }
        }
    }

    public static TTarget Reinterpret<TTarget, TSource>(TSource source)
    {
        TSource[] sourceBuffer = ThreadLocalType<TSource>.Buffer;
        TTarget[] targetBuffer = ThreadLocalType<TTarget>.Buffer;

        int sourceSize = Buffer.ByteLength(sourceBuffer);
        int destSize = Buffer.ByteLength(targetBuffer);
        if (sourceSize != destSize) {
            throw new ArgumentException("Cannot convert " + typeof(TSource).FullName + " to " + typeof(TTarget).FullName + ". Data types are of different sizes.");
        }

        sourceBuffer[0] = source;
        Buffer.BlockCopy(sourceBuffer, 0, targetBuffer, 0, sourceSize);
        return targetBuffer[0];
    }
}

class Program {
    static void Main(string[] args)
    {
        Console.WriteLine("Float: " + Cast.Reinterpret<int, float>(100));
        Console.ReadKey();
    }
}

Answer 3

I used the code from FastArraySerializer to create a type converter to get from SByte[] to Double[]

public unsafe class ConvertArrayType
{
    [StructLayout(LayoutKind.Explicit)]
    private struct Union
    {
        [FieldOffset(0)] public sbyte[] sbytes;
        [FieldOffset(0)] public double[] doubles;
    }

    private Union _union; 
    public double[] doubles {
        get { return _union.doubles; }
    }
    public sbyte[] sbytes
    {
        get { return _union.sbytes; }
    }

    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    private struct ArrayHeader
    {
        public UIntPtr type;
        public UIntPtr length;
    }

    private readonly UIntPtr SBYTE_ARRAY_TYPE;
    private readonly UIntPtr DOUBLE_ARRAY_TYPE;

    public ConvertArrayType(Array ary, Type newType)
    {
        fixed (void* pBytes = new sbyte[1])
        fixed (void* pDoubles = new double[1])
        {
            SBYTE_ARRAY_TYPE = getHeader(pBytes)->type;
            DOUBLE_ARRAY_TYPE = getHeader(pDoubles)->type;
        }
        Type typAry = ary.GetType();
        if (typAry == newType)
            throw new Exception("No Type change specified");
        if (!(typAry == typeof(SByte[]) || typAry == typeof(double[])))
            throw new Exception("Type Not supported");

        if (newType == typeof(Double[]))
        {
            ConvertToArrayDbl((SByte[])ary);
        }
        else if (newType == typeof(SByte[]))
        {
            ConvertToArraySByte((Double[])ary);
        }
        else
        {
            throw new Exception("Type Not supported");
        }
    }

    private void ConvertToArraySByte(double[] ary)
    {
        _union = new Union { doubles = ary };
        toArySByte(_union.doubles);
    }
    private void ConvertToArrayDbl(sbyte[] ary)
    {
        _union = new Union { sbytes = ary };
        toAryDouble(_union.sbytes);
    }

    private ArrayHeader* getHeader(void* pBytes)
    {
        return (ArrayHeader*)pBytes - 1;
    }

    private void toAryDouble(sbyte[] ary)
    {
        fixed (void* pArray = ary)
        {
            var pHeader = getHeader(pArray);
            pHeader->type = DOUBLE_ARRAY_TYPE;
            pHeader->length = (UIntPtr)(ary.Length / sizeof(double));
        }
    }

    private void toArySByte(double[] ary)
    {
        fixed (void* pArray = ary)
        {
            var pHeader = getHeader(pArray);
            pHeader->type = SBYTE_ARRAY_TYPE;
            pHeader->length = (UIntPtr)(ary.Length * sizeof(double));
        }
    }
} // ConvertArrayType{}

Here's the VB usage:

Dim adDataYgch As Double() = Nothing
Try
    Dim nGch As GCHandle = GetGch(myTag)
    If GCHandle.ToIntPtr(nGch) <> IntPtr.Zero AndAlso nGch.IsAllocated Then
        Dim asb As SByte()
        asb = CType(nGch.Target, SByte())
        Dim cvt As New ConvertArrayType(asb, GetType(Double()))
        adDataYgch = cvt.doubles
    End If
Catch ex As Exception
    Debug.WriteLine(ex.ToString)
End Try

Answer 4

You can achieve this but this is a relatively bad idea. Raw memory access like this is not type-safe and can only be done under a full trust security environment. You should never do this in a properly designed managed application. If your data is masquerading under two different forms, perhaps you actually have two separate data sets?

In any case, here is a quick and simple code snippet to accomplish what you asked:

byte[] bytes = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int byteCount = bytes.Length;

unsafe
{
    // By using the fixed keyword, we fix the array in a static memory location.
    // Otherwise, the garbage collector might move it while we are still using it!
    fixed (byte* bytePointer = bytes)
    {
        short* shortPointer = (short*)bytePointer;

        for (int index = 0; index < byteCount / 2; index++)
        {
            Console.WriteLine("Short {0}: {1}", index, shortPointer[index]);
        }
    }
}

Answer 5

You could wrap your shorts/bytes into a structure which allows you to access both values:

See also here: C++ union in C#

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;

namespace TestShortUnion {
    [StructLayout(LayoutKind.Explicit)]
    public struct shortbyte {
        public static implicit operator shortbyte(int input) {
            if (input > short.MaxValue)
                throw new ArgumentOutOfRangeException("input", "shortbyte only accepts values in the short-range");
            return new shortbyte((short)input);
        }

        public shortbyte(byte input) {
            shortval = 0;
            byteval = input;
        }

        public shortbyte(short input) {
            byteval = 0;
            shortval = input;
        }

        [FieldOffset(0)]
        public byte byteval;
        [FieldOffset(0)]
        public short shortval;
    }

    class Program {
        static void Main(string[] args) {
            shortbyte[] testarray = new shortbyte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1111 };

            foreach (shortbyte singleval in testarray) {
                Console.WriteLine("Byte {0}: Short {1}", singleval.byteval, singleval.shortval);
            }

            System.Console.ReadLine();
        }
    }
}

Answer 6

Wouldn't it be possible to create a collection class that implements an interface for both bytes and shorts? Maybe implement both IList< byte > and IList< short >? Then you can have your underlying collection contain bytes, but implement IList< short > functions that work on byte pairs.

Answer 7

This kind of behaviour would result in C# being rather type-unsafe. You can easily achieve this in a type-safe manner, however (though of course you are copying the array in doing so).

If you want one byte to map to one short then it's simple using ConvertAll, e.g.:-

short[] shorts = Array.ConvertAll(bytes, b => (short)b);

If you want to simply map every 2 bytes to a short then the following should work:-

if (bytes.Length % 2 != 0)
{
    throw new ArgumentException("Byte array must have even rank.");
}

short[] shorts = new short[bytes.Length / 2];
for (int i = 0; i < bytes.Length / 2; ++i)
{
    shorts[i] = BitConverter.ToInt16(bytes, 2*i);
}

It may be possible to use the marshaller to do some weird bit-twiddling to achieve this, probably using an unsafe { ... } code block, though this would be prone to errors and make your code unverifiable.

I suspect what you're trying to do can be achieved better using a type-safe idiom rather than a type-unsafe C/C++ one!

Update: Updated to take into account comment.

Answer 8

c# supports this so long as you are willing to use unsafe code but only on structs.

for example : (The framework provides this for you but you could extend this to int <-> uint conversion

public unsafe long DoubleToLongBits(double d)
{
    return *((long*) (void*) &d);
}

Since the arrays are reference types and hold their own metadata about their type you cannot reinterpret them without overwriting the metadata header on the instance as well (an operation likely to fail).

You can howveer take a foo* from a foo[] and cast that to a bar* (via the technique above) and use that to iterate over the array. Doing this will require you pin the original array for the lifetime of the reinterpreted pointer's use.

Answer 9

Casting like this is fundamentally unsafe and not permitted in a managed language. That's also why C# doesn't support unions. Yes, the workaround is to use the Marshal class.