Reference Array in C#?

Question

I have byte array:

byte[] alldata = new byte[1024];

then I need to convert this data to UInt32:

UInt32[] block32 = new UInt32[(int)Math.Ceiling((double)alldata.Length / 4)];
Buffer.BlockCopy(alldata, 0, block32, 0, alldata.Length);

after this I need to convert block32 back to byte array.

The question is whether I can have the block32 array just be a 32-bit reference array of my byte array to avoid converting to UInt32 and back?

Answer 1

Your question isn't entirely clear - but a reference is only ever to a single object, and an array object "knows" its real type... you can't just treat a uint[] as if it were a byte[] or vice versa.

Now what you could do is hide that behind another object. You could have a single byte array which is shared between an ByteArrayView and an UInt32ArrayView where those classes each know how to address a single underlying byte array. You'd have to write those classes yourself though - I don't believe they exist anywhere in the existing framework.

You could potentially create an abstract class or interface which those disparate classes would implement, too, e.g.

class ByteArrayView : IArrayView<byte>
class UInt32ArrayView : IArrayView<uint>

(Or just implement IList<T> appropriately, of course...)

Answer 2

I've reworked an answer I found here from Omer Mor. This basically uses unsafe code to temporarily change the type the array thinks it is.

On the plus side, you don't need to rewrite any of your other code to use unsafe pointers or wrapper classes. On the downside, this is not only unsafe code, but nasty unsafe code that messes with the type system.

static class ArrayCaster
{
    [StructLayout(LayoutKind.Explicit)]
    private struct Union
    {
        [FieldOffset(0)]
        public Byte[] Bytes;
        [FieldOffset(0)]
        public UInt32[] UInt32s;
    }

    static unsafe int UInt32Id
    {
        get
        {
            fixed (UInt32* pUints = new UInt32[1])
            {
                var pBytes = (Byte*)pUints;
                return *(int*)(pBytes - 8);
            }
        }
    }

    static unsafe void SetSizeAndId(
        byte[] bytes,
        int newSize, int newId,
        out int oldSize, out int oldId)
    {
        fixed (Byte* pBytes = bytes)
        {
            int* size = (int*)(pBytes - 4);
            oldSize = *size;
            *size = newSize;
            int* id = (int*)(pBytes - 8);
            oldId = *id;
            *id = newId;
        }
    }

    public static void WithBytesAsUInt32s(
        Byte[] bytes, Action<UInt32[]> withUints)
    {
        if (bytes.Length % sizeof(UInt32) != 0) throw new ArgumentException();

        Union u = new Union { Bytes = bytes };
        int origSize, origId;
        SetSizeAndId(bytes, bytes.Length / sizeof(UInt32), UInt32Id,
                     out origSize, out origId);
        try
        {
            withUints(u.UInt32s);
        }
        finally
        {
            SetSizeAndId(bytes, origSize, origId, out origSize, out origId);
        }
    }
}

In your code:

byte allData = new byte[1024];
ArrayCaster.WithBytesAsUInt32s(allData, uintArray => Encrypt(unitArray));

---

Edit: On the offchance that your encrypt/decrypt methods take an explicit length as well as the UInt32 array, you can cut out the unsafe code completely; just using the Union works fine except (a) the debugger inspector gets confused, and (b) the length doesn't update. If you can tell your methods to only use a quarter of the array, you're golden.

Answer 3

As you already mentioned you will use the uint[] for encryption.

Because of some reasons, you copy arrays with BlockCopy. But you want to access byte[] like an uint[], without converting or casting the entire array.

Then, what's something not enough? Is there something in C# can do this?

After think for one more hour, I guess what you want it for, should be the indexer.

Here's the code. It's simple.

public partial class UIntIndexer {
    static int ComputeElementCount(int size, int bytesCount) {
        var r=~0;
        return Math.DivRem(bytesCount, size, out r)+(r>0?1:0);
    }

    static int ComputeIndex(int index) {
        return sizeof(uint)*index;
    }

    public UIntIndexer(byte[] array) {
        m_Length=ComputeElementCount(sizeof(uint), (m_Array=array).Length);
    }

    public uint this[int index] {
        set {
            var startIndex=ComputeIndex(index);
            var bytes=BitConverter.GetBytes(value);
            var count=m_Length>1+index?sizeof(uint):m_Array.Length-startIndex;
            Buffer.BlockCopy(bytes, 0, m_Array, startIndex, count);
        }

        get {
            var startIndex=ComputeIndex(index);

            if(m_Length>1+index)
                return BitConverter.ToUInt32(m_Array, startIndex);
            else {
                var bytes=new byte[sizeof(uint)];
                Buffer.BlockCopy(m_Array, startIndex, bytes, 0, m_Array.Length-startIndex);
                return BitConverter.ToUInt32(bytes, 0);
            }
        }
    }

    public int Length {
        get {
            return m_Length;
        }
    }

    byte[] m_Array;
    int m_Length;
}

If thread safety should be concerned, you might need to keep the the source array synchronized. Following is the code for test it:

var alldata=new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
var block32=new byte[alldata.Length];
var uintIndexer=new UIntIndexer(block32);
Buffer.BlockCopy(alldata, 0, block32, 0, alldata.Length);

Debug.Print("uintIndexer.Length={0}", uintIndexer.Length);

for(var i=uintIndexer.Length; i-->0; )
    Debug.Print("uintIndexer[{0}]={1}", i, uintIndexer[i]);