Casting sbyte[] to bool[] and a char[] to short[]

Question

Is there anyway to explicitly cast/coerce

• sbyte[] or byte[] to a bool[]
• char[] to a short[]/ushort[]

In CIL you regularly see something such as

stelem Type sbyte (ldloc pArray) ldc_i4 1 ldc_i4 0 

which is doing pArray[1] = true where pArray is a one-dimensional array of type bool[]. I want to replicate this in c# by doing

(sbyte[])pArray[1] = 1;

Unfortunately this is not allowed by the C# compiler.

Answer 1

Undocumented trick, play at your own risk:

(shown for example here and in many other places)

[StructLayout(LayoutKind.Explicit)]
public struct ConvSByteBool
{
    [FieldOffset(0)]
    public sbyte[] In;
    [FieldOffset(0)]
    public bool[] Out;
}

and then:

var bytes = new sbyte[] { -2, -1, 0, 1, 2 };
var conv = new ConvSByteBool { In = bytes }.Out;
bool b1 = conv[0]; // true
bool b2 = conv[1]; // true
bool b3 = conv[2]; // false
bool b4 = conv[3]; // true
bool b5 = conv[4]; // true

Note that this trick is tottally incompatible with generics. No Conv<T, U>!

The trick works best when the size of the element in source and target is the same (sizeof(sbyte) == sizeof(bool)). Otherwise there are some limitations (described in the linked question above).

Answer 2

You can use the new Span<T> and MemoryMarshal types to do this.

Note that this is only available with recent versions of C#, and you have to use a NuGet package to provide the library at the moment, but that will change.

So for example to "cast" a char array to a short array, you can write code like this:

var         charArray  = new char[100];
Span<short> shortArray = MemoryMarshal.Cast<char, short>(charArray);

charArray[0] = 'X';
Console.WriteLine(charArray[0]); // Prints 'X'
++shortArray[0];
Console.WriteLine(charArray[0]); // Prints 'Y'

This approach is documented and does not make any copies of any data - and it's also extremely performant (by design).

Note that this also works with structs:

struct Test
{
    public int X;
    public int Y;

    public override string ToString()
    {
        return $"X={X}, Y={Y}";
    }
}

...

var testArray = new Test[100];
Span<long> longArray = MemoryMarshal.Cast<Test, long>(testArray);

testArray[0].X = 1;
testArray[0].Y = 2;

Console.WriteLine(testArray[0]); // Prints X=1, Y=2

longArray[0] = 0x0000000300000004;

Console.WriteLine(testArray[0]); // Prints X=4, Y=3

Also note that this allows you to do some suspect things, like this:

struct Test1
{
    public int X;
    public int Y;

    public override string ToString()
    {
        return $"X={X}, Y={Y}";
    }
}

struct Test2
{
    public int X;
    public int Y;
    public int Z;

    public override string ToString()
    {
        return $"X={X}, Y={Y}, Z={Z}";
    }
}

...

var         test1 = new Test1[100];
Span<Test2> test2 = MemoryMarshal.Cast<Test1, Test2>(test1);

test1[1].X = 1;
test1[1].Y = 2;

Console.WriteLine(test1[1]); // Prints X=1, Y=2

test2[0].Z = 10; // Actually sets test1[1].X.

Console.WriteLine(test1[1]); // Prints X=10, Y=2

Answer 3

This is a partial answer only.

Hack:

The C# compiler and the run-time do not agree entirely on what array types are convertible to each other (as you are hinting at in your question). So you can avoid asking the compiler and defer the cast to run-time, by going through System.Array (or System.Object or System.Collections.IEnumerable etc.).

An example:

using System;

static class P
{
  static void Main()
  {
    var a = new sbyte[] { -7, -3, 8, 11, };
    var hack = (byte[])(Array)a;
    Console.WriteLine(string.Join("\r\n", hack));
  }
}

Try it online (tio.run)

Output:

249
253
8
11

If you were to avoid the intermediate (Array) in the code above, the C# compiler would tell you that the cast is impossible.

Answer 4

You can use an extension method, like this:

namespace ExtensionMethods
{
    public static class ByteExt
    {
        public static bool ToBool(this byte b) => b != 0;
        public static bool[] ToBoolArray(this byte[] bytes)
        {
            bool[] returnValues = new bool[bytes.Length];

            for (int i = 0; i < bytes.Length; i++)
                returnValues[i] = bytes[i].ToBool();

            return returnValues;
        }

        // Do same for sbyte
    }
    public static class CharExt
    {
        public static short[] ToBoolArray(this char[] chars)
        {
            short[] returnValues = new bool[chars.Length];

            for (int i = 0; i < chars.Length; i++)
                returnValues[0] = (short)chars[0];

            return returnValues;
        }
    }
}

Then just use it like this:

byte[] myBytes = new[] {1, 2, 5};
bool[] myBools = myBytes.ToBoolArray();

In C# 8, there will probably be what's called "Extension Everything", where you'll be able to define your own extension casts, both explicit and implicit.

The syntax will be something like this:

public extension class ByteExt extends Byte[]
{
    public static explicit operator bool[](byte[] bytes)
    {
         // Same implementation as before
    }
}

And can use it like this:

byte[] myBytes = new[] {1, 2, 5};
bool[] myBools = (bool[])myBytes;

Answer 5

Use Array.ConvertAll as follow:

// Input
sbyte[] sbyteArray = { 0, 1, 2, 0 };
byte[] byteArray = { 0, 1, 2, 0 };
// Result
bool[] boolArray1 = Array.ConvertAll(sbyteArray, (item) => Convert.ToBoolean(item));
bool[] boolArray2 = Array.ConvertAll(byteArray, (item) => Convert.ToBoolean(item));

// Input
char[] charArray = { 'A', 'B', 'C' };
// Result
short[] shortArray = Array.ConvertAll(charArray, (item) => Convert.ToInt16(item));
ushort[] ushortArray = Array.ConvertAll(charArray, (item) => Convert.ToUInt16(item));