ByteArray class for C#

Question

I'm trying to translate a function from ActionScript 3 into C# .NET.

What I have trouble is how to properly use ByteArrays in C#. In As3 there is a specific Class for it that already has most of the functionality i need, but in C# nothing of that sort seems to exist and I can't wrap my head around it.

This is the As3 function:

private function createBlock(type:uint, tag:uint,data:ByteArray):ByteArray
        {
            var ba:ByteArray = new ByteArray();
            ba.endian = Endian.LITTLE_ENDIAN;
            ba.writeUnsignedInt(data.length+16);
            ba.writeUnsignedInt(0x00);
            ba.writeUnsignedInt(type);
            ba.writeUnsignedInt(tag);
            data.position = 0;
            ba.writeBytes(data);
            ba.position = 0;

            return ba;  
        }

But from what I gather, in C# I have to use a normal Array with the byte type, like this

byte[] ba = new byte[length];

Now, I looked into the Encoding Class, the BinaryWriter and BinaryFormatter class and researched if somebody made a Class for ByteArrays, but with no luck.

Can somebody nudge me in the right direction please?

Answer 1

You should be able to do this using a combination of MemoryStream and BinaryWriter:

public static byte[] CreateBlock(uint type, uint tag, byte[] data)
{
    using (var memory = new MemoryStream())
    {
        // We want 'BinaryWriter' to leave 'memory' open, so we need to specify false for the third
        // constructor parameter. That means we need to also specify the second parameter, the encoding.
        // The default encoding is UTF8, so we specify that here.

        var defaultEncoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier:false, throwOnInvalidBytes:true);

        using (var writer = new BinaryWriter(memory, defaultEncoding, leaveOpen:true))
        {
            // There is no Endian - things are always little-endian.

            writer.Write((uint)data.Length+16);
            writer.Write((uint)0x00);
            writer.Write(type);
            writer.Write(data);
        }

        // Note that we must close or flush 'writer' before accessing 'memory', otherwise the bytes written
        // to it may not have been transferred to 'memory'.

        return memory.ToArray();
    }
}

However, note that BinaryWriter always uses little-endian format. If you need to control this, you can use Jon Skeet's EndianBinaryWriter instead.

As an alternative to this approach, you could pass streams around instead of byte arrays (probably using a MemoryStream for implementation), but then you will need to be careful about lifetime management, i.e. who will close/dispose the stream when it's done with? (You might be able to get away with not bothering to close/dispose a memory stream since it uses no unmanaged resources, but that's not entirely satisfactory IMO.)