Converting a byte array to an array of primitive types with unknown type in C#

Here's my ideas:

object[] primitiveData = new object[byteData.Lenght];
for (int i = 0; i < bytesData.Lenght; i++)
{
     primitiveData[i] = Converter.ChangeType(bytesData[i], types[i]);
}

object[] primitiveData = new object[bytDate.Lenght];
for (int i = 0; i < bytesDate.Lenght; i++)
{
     Type t = types[i];
     if (t == typeof(int))
     {
          primitiveData[i] = Convert.ToInt32(bytesDate[i]);
     }
     else if (t == typeof(short))
     {
          primitiveData[i] = Convert.ToInt16(bytesDate[i]);
     }
     ..
}

var dic = new Dictionary<Type, Func<byte, object>>
{
    { typeof(int), b => Convert.ToInt32(b) },
    { typeof(short), b => Convert.ToInt16(b) },
    ...
};

byte[] byteData = new byte[] { 0xa0, 0x14, 0x72, 0xbf, 0x72, 0x3c, 0x21 };
Type[] types = new Type[] { typeof(int), typeof(short), typeof(sbyte) };

List<object> list = new List<object>(primitiveData.Length);
for (int i = 0; i < primitiveData.Length; i++)
{
     Byte b = byteData[i];
     Type t = types[i];
     Func<byte, object> func = dic[t];
     list.Add(func(b));
}
object[] primitiveData = list.ToArray();

byte[] byteData = new byte[] { 0xa0, 0x14, 0x72, 0xbf, 0x72, 0x3c, 0x21 };
// delegates to converters instead of just appropriate types
Func<byte, object>[] funcs = new Func<byte, object>[]
{
     b => Convert.ToInt32(b),
     b => Convert.ToInt16(b),
     b => Convert.ToSByte(b)
};

List<object> list = new List<object>(primitiveData.Length);
for (int i = 0; i < primitiveData.Length; i++)
{
     Byte b = byteData[i];
     Func<byte, object> func = funcs[i];
     list.Add(func(b));
}
object[] primitiveData = list.ToArray();

Note, that all my solutions above assumes the symmetry between byteData and types.

Otherwise you have to prepare a symmetric array which will contain an index of asymmetric array:

byte[] byteData = new byte[] { 0xa0, 0x14, 0x72, 0xbf, 0x72, 0x3c, 0x21 };
Type[] types = new Type[] { typeof(int), typeof(short), typeof(sbyte) }; // asymmetric 
int[] indexes = new int[] { 0, 0, 0, 0, 1, 2 }; // symmetric 

You could use a BinaryReader:

public static IEnumerable<object> ConvertToObjects(byte[] byteData, Type[] types)
{
    using (var stream = new MemoryStream(byteData))
    using (var reader = new BinaryReader(stream))
    {
        foreach (var type in types)
        {
            if (type == typeof(short))
            {
                yield return reader.ReadInt16();
            }
            else if (type == typeof(int))
            {
                yield return reader.ReadInt32();
            }
            else if (type == typeof(sbyte))
            {
                yield return reader.ReadSByte();
            }
            // ... other types
            else
            {
                throw new NotSupportedException(string.Format("{0} is not supported", type));
            }
        }
    }
}

And then:

byte[] byteData = new byte[] { 0xa0, 0x14, 0x72, 0xbf, 0x72, 0x3c, 0x21 };
Type[] types = new Type[] { typeof(int), typeof(short), typeof(sbyte) };
object[] result = ConvertToObjects(byteData, types).ToArray();

Little dirty but it works... sp is used to point to where to read from next in byteData, checking of types can be done some other way I guess... but this is just an idea. So please no -1 me if you dont like it. =)

        byte[] byteData = new byte[] { 0xa0, 0x14, 0x72, 0xbf, 0x72, 0x3c, 0x21 };
        Type[] types = new Type[] {typeof(int),typeof(short),typeof(sbyte)};

        object[] primitiveData = new object[types.Length];
        int sp = 0;

        for(int i=0; i<types.Length; i++)
        {

            string s = types[i].FullName;
            switch(types[i].FullName)
            {
                case "System.Int32":{
                    primitiveData[i] = BitConverter.ToInt32(byteData, sp);
                    sp += 4;
                }break;
                case "System.Int16":
                    {
                    primitiveData[i] = BitConverter.ToInt16(byteData, sp);
                    sp += 2;
                }break;
                case "System.SByte":
                    {
                    primitiveData[i] = (sbyte)byteData[sp];
                    sp += 1;
                }break;

            }
        }

You can use reflection to create the arrays and fill them. (Notice the error handler due to wrong data for SByte):

  [TestMethod]
  public void MyTestMethod() {
     byte[] byteData = new byte[] { 0xa0, 0x14, 0x72, 0xbf, 0x72, 0x3c, 0x21 };
     Type[] types = new Type[] { typeof(int), typeof(short), typeof(sbyte) };

     List<Array> result = new List<Array>();

     foreach (var type in types) {
        Type arrayType = type.MakeArrayType();
        ConstructorInfo ctor = arrayType.GetConstructor(new Type[] { typeof(int) });
        Array array = (Array)ctor.Invoke(new object[] { byteData.Length });

        for (int i = 0; i < byteData.Length; i++) {
           byte b = byteData[i];
           try {
              array.SetValue(Convert.ChangeType(b, type), i);
           } catch {
              Console.WriteLine("Error with type {0} and value {1}", type, b);
           }
        }

        result.Add(array);
     }

     // -------------------
     // show result
     foreach (var array in result) {
        Console.WriteLine(array.GetType());
        foreach (var item in array) {
           Console.WriteLine("   {0}", item);
        }
     }
  }