C# - Converting a Sequence of Numbers into Bytes

Question

I am trying to send a UDP packet of bytes corresponding to the numbers 1-1000 in sequence. How do I convert each number (1,2,3,4,...,998,999,1000) into the minimum number of bytes required and put them in a sequence that I can send as a UDP packet?

I've tried the following with no success. Any help would be greatly appreciated!

 List<byte> byteList = new List<byte>();

        for (int i = 1; i <= 255; i++)
        {
            byte[] nByte = BitConverter.GetBytes((byte)i);
            foreach (byte b in nByte)
            {
                byteList.Add(b);
            }
        }

        for (int g = 256; g <= 1000; g++)
        {
            UInt16 st = Convert.ToUInt16(g);
            byte[] xByte = BitConverter.GetBytes(st);
            foreach (byte c in xByte)
            {
                byteList.Add(c);
            }
        }


        byte[] sendMsg = byteList.ToArray();

Thank you.

Answer 1

A byte can only hold 256 distinct values, so you cannot store the numbers above 255 in one byte. The easiest way would be to use short, which is 16 bits. If you realy need to conserve space, you can use 10 bit numbers and pack that into a byte array ( 10 bits = 2^10 = 1024 possible values).

Answer 2

You need to use :

BitConverter.GetBytes(INTEGER);

Answer 3

Naively (also, untested):

List<byte> bytes = new List<byte>();

for (int i = 1; i <= 1000; i++)
{
    byte[] nByte = BitConverter.GetBytes(i);
    foreach(byte b in nByte) bytes.Add(b);
}

byte[] byteStream = bytes.ToArray();

Will give you a stream of bytes were each group of 4 bytes is a number [1, 1000].

---

You might be tempted to do some work so that i < 256 take a single byte, i < 65535 take two bytes, etc. However, if you do this you can't read the values out of the stream. Instead, you'd add length encoding or sentinels bits or something of the like.

I'd say, don't. Just compress the stream, either using a built-in class, or gin up a Huffman encoding implementation using an agree'd upon set of frequencies.

Answer 4

Think about how you are going to be able to tell the difference between:

260, 1  -> 0x1, 0x4, 0x1
1, 4, 1 -> 0x1, 0x4, 0x1

If you use one byte for numbers up to 255 and two bytes for the numbers 256-1000, you won't be able to work out at the other end which number corresponds to what.

If you just need to encode them as described without worrying about how they are decoded, it smacks to me of a contrived homework assignment or test, and I'm uninclined to solve it for you.

Answer 5

I think you are looking for something along the lines of a 7-bit encoded integer:

protected void Write7BitEncodedInt(int value)
{
    uint num = (uint) value;
    while (num >= 0x80)
    {
        this.Write((byte) (num | 0x80));
        num = num >> 7;
    }
    this.Write((byte) num);
}

(taken from System.IO.BinaryWriter.Write(String)).

The reverse is found in the System.IO.BinaryReader class and looks something like this:

protected internal int Read7BitEncodedInt()
{
    byte num3;
    int num = 0;
    int num2 = 0;
    do
    {
        if (num2 == 0x23)
        {
            throw new FormatException(Environment.GetResourceString("Format_Bad7BitInt32"));
        }
        num3 = this.ReadByte();
        num |= (num3 & 0x7f) << num2;
        num2 += 7;
    }
    while ((num3 & 0x80) != 0);
    return num;
}

I do hope this is not homework, even though is really smells like it.

EDIT:

Ok, so to put it all together for you:

using System;
using System.IO;

namespace EncodedNumbers
{
    class Program
    {
        protected static void Write7BitEncodedInt(BinaryWriter bin, int value)
        {
            uint num = (uint)value;
            while (num >= 0x80)
            {
                bin.Write((byte)(num | 0x80));
                num = num >> 7;
            }
            bin.Write((byte)num);
        }


        static void Main(string[] args)
        {
            MemoryStream ms = new MemoryStream();
            BinaryWriter bin = new BinaryWriter(ms);

            for(int i = 1; i < 1000; i++)
            {
                Write7BitEncodedInt(bin, i);
            }

            byte[] data = ms.ToArray();
            int size = data.Length;
            Console.WriteLine("Total # of Bytes = " + size);

            Console.ReadLine();
        }
    }
}

The total size I get is 1871 bytes for numbers 1-1000. Btw, could you simply state whether or not this is homework? Obviously, we will still help either way. But we would much rather you try a little harder so you can actually learn for yourself.

EDIT #2:

If you want to just pack them in ignoring the ability to decode them back, you can do something like this:

    protected static void WriteMinimumInt(BinaryWriter bin, int value)
    {
        byte[] bytes = BitConverter.GetBytes(value);
        int skip = bytes.Length-1;
        while (bytes[skip] == 0)
        {
            skip--;
        }
        for (int i = 0; i <= skip; i++)
        {
            bin.Write(bytes[i]);
        }
    }

This ignores any bytes that are zero (from MSB to LSB). So for 0-255 it will use one byte. As states elsewhere, this will not allow you to decode the data back since the stream is now ambiguous. As a side note, this approach crams it down to 1743 bytes (as opposed to 1871 using 7-bit encoding).