Лучший способ реализовать сбор массива разных типов

Вы можете рассматривать это как список byte[] и сериализовать типы значений с помощью BitConverter, чтобы преобразовать тип значения в byte[], а затем развернуть его с помощью обратного вызова;

List<byte[]> dataList = new List<byte[]>();
float v = 1.0424f;
byte[] converted = BitConverter.GetBytes(v);
// put converted into a List<byte[]> 
dataList.Add(converted);
// Convert it back again
float z= BitConverter.ToSingle(dataList[0], 0);

Можете ли вы просто сериализовать данные в JSON или MessagePack и сохранить их в виде массива строк? Кажется, что это было бы относительно просто реализовать и легко использовать.

floats будут проблематичными, когда требуется устойчивая точность в C # ... период. Это печально, потому что мы все знаем, как сильно мы любим точность. Но я не думаю, что C# — единственный язык, страдающий от этой болезни. Тем не менее, я думаю, что есть способ добиться того, чего вы хотите, и ваша оболочка — хорошее начало.

Я не знаком с тем, что вы используете (сторонняя библиотека), поэтому я просто предложу решение вопроса.

Если вы знаете, какой тип вы извлекаете, я бы рекомендовал использовать byte[]. Таким образом, вы могли бы эффективно хранить 3 byte[] в одном списке.

var dataList = new List<byte[]>();
dataList.Add(ConvertUsTime(p.time_US));
dataList.Add(ConvertVelocity(p.velocity));
dataList.Add(ConvertStatus(p.status));

byte[] ConvertToArray(long usTime) {
    return BitConverter.GetBytes(usTime);
}

byte[] ConvertVelocity(Int16 velocity) {
    return BitConverter.GetBytes(velocity);
}

byte[] ConvertStatus(UInt32 status) {
    return BitConverter.GetBytes(status);
}

... для более общего метода:

byte[] ConvertValue<T>(T value) where T : struct {
    // we have to test for type of T and can use the TypeCode for switch statement
    var typeCode = Type.GetTypeCode(typeof(T));

    switch(typeCode) {
        case TypeCode.Int64:
            return BitConverter.GetBytes((long)value);

        case TypeCode.Int16:
            return BitConverter.GetBytes((Int16)value);

        case TypeCode.UInt32:
            return BitConverter.GetBytes((UInt32)value);
    }

    return null;
}

В качестве контрпримера к подходу с общим списком я хотел бы упомянуть, что пример списка, связанный с вопросом, не следует считать продвинутым. Он использует интерфейс, который является тривиальным C#.

Использование разных типов, реализующих один и тот же интерфейс, может быть лучшим решением, если вы хотите отладить содержимое списка или ожидаете, что бизнес-логика для разных типов коллекций будет расти. Прямо сейчас у вас есть только GetSI(), но он может расширяться за счет более общих методов, которые имеют конкретные реализации для каждого типа сбора пакетов. Наконец, списки отладки, содержащие общие объекты или необработанные байты, вероятно, не очень хорошо поддерживаются вашим отладчиком IDE. Интерфейсы хорошо поддерживаются. Реализация, иллюстрирующая идею, показана ниже.

public example() {

    Packet[] array_of_packet = GetArrayofPacketFromHardware();

    var time_uS = array_of_packet.Select(p => p.time_uS).ToArray();
    var velocity = array_of_packet.Select(p => p.velocity).ToArray();
    var status_bits = array_of_packet.Select(p => p.status_word).ToArray();

    List<IPacketCollection> collection = new List<IPacketCollection> { };
    collection.Add(new TimePacketCollection(time_uS));
    collection.Add(new VelocityPacketCollection(velocity));
    collection.Add(new StatusPacketCollection(status_bits));  

    // Now we have benefits over generic objects or byte arrays.
    // We can extend our collections with additional logic as your 
    // Application grows or right now already still benefit from the 
    // GetSI you mentioned as a plus in your question.
    foreach(var velocityPacketCollection in collection.OfType<VelocityPacketCollection>()) {
        // specific velocity collection things here.
        // Also your debugger is perfectly happy peeking in the collection.
    }

    // or generic looping accessing the GetSI()
    foreach(var packetCollection in collection) {
        System.Debug.Println(packetCollection.GetSI());
    }
}

public interface IPacketCollection {
    /// <summary>
    /// Not sure what this method should do but it seems it 
    /// always returns double precision or something?
    /// </summary>
    public double[] GetSI;
} 

public class TimePacketCollection : IPacketCollection {
    private const double scaleFactor = 1.0e-6;
    private long[] timePacketArray;

    public TimePacketCollection(long[] timeArray) {
        timePacketArray = timeArray;
    }

    public double[] GetSI(){
         // no IDE available. Not sure if this automatically converts to 
         // double due to multiplication with a double.
         return timePacketArray.Select(item => scaleFactorToSI * item).ToArray();
    }
}

public class VelocityPacketCollection : IPacketCollection {
    private const double scaleFactor = 1/8192;
    private Int16[] velocityPacketArray;

    public VelocityPacketCollection (Int16[] velocities) {
        velocityPacketArray = velocities;
    }

    public double[] GetSI(){
         // no IDE available. Not sure if this automatically converts to 
         // double due to multiplication with a double.
         return velocityPacketArray.Select(item => scaleFactorToSI * item).ToArray();
    }
}

public class StatusPacketCollection : IPacketCollection {
    private const double scaleFactor = 1.0;
    private UInt32[] statusPacketArray;

    public StatusPacketCollection (UInt32[] statuses) {
        statusPacketArray = statuses;
    }

    public double[] GetSI(){
         // no IDE available. Not sure if this automatically converts to 
         // double due to multiplication with a double.
         return statusPacketArray.Select(item => scaleFactorToSI * item).ToArray();
    }
}

Отказ от ответственности: я написал это с устройства без IDE. Я абсолютно катастрофически пишу код без моей IDE, исправляющей меня от глупых ошибок, поэтому, если это не скомпилируется, пожалуйста, потерпите меня. Я думаю, что общая идея ясна.

Ответ на вопрос "Есть ли лучший способ в C#?" - Да.

Используйте List<dynamic> в качестве коллекции для ваших массивов.

List<dynamic> array_list = new List<dynamic> { };
public void AddArray(dynamic dynamic_array)
{
   this.array_list.Add(dynamic_array);
}

Конечно, в него можно передать что угодно, но это можно проверить.

List<dynamic> в этой ситуации лучше, чем ArrayList, так как при попытке проиндексировать массив, взятый из "списка", IDE помечает ошибку.

int ndx = 0;
foreach (var array_from_list in this.array_list) {                
  var v = array_from_list[ndx];  // error if array_from_list is ArrayList
}

Далее следует полная иллюстрация (но она лишь концептуально повторяет описанную выше оболочку).

using System;
using System.Collections.Generic;


namespace Application
{
    class MyTest
    {
        List<dynamic> array_list = new List<dynamic> { };
        int length;

        public void AddArray(dynamic dynamic_array)
        {
            this.array_list.Add(dynamic_array);
            this.length = dynamic_array.Length;
        }
        public dynamic GetVector(int ndx)
        {
            return array_list[ndx];
        }
        public void Display()
        {
            for (int ndx = 0; ndx < this.length; ndx++)
            {
                string ln_txt = "";
                foreach (var array_from_list in this.array_list)
                {
                    string s = array_from_list[ndx].ToString();
                    ln_txt += $"{s} ";
                }

                Console.WriteLine(ln_txt);
            }

        }
    }

    static class Program
    {


        [STAThread]
        static void Main(string[] args)
        {

            MyTest test = new MyTest();
            test.AddArray(new long[] { 10, 20, 30, 40 });
            test.AddArray(new int[] { 1, 2, 3, 4 });
            test.AddArray(new double[] { .1, .2, .3, .4 });
            test.AddArray(new string[] { "a", "b", "c", "d" });
            test.Display();


            for (int vecnum = 0; vecnum < 4; vecnum++)
            {
                var vector = test.GetVector(vecnum);
                Console.Write($"vnum:{vecnum} :   ");

                foreach (var value in vector)
                {
                    Console.Write($"{value}   ");
                }
                Console.WriteLine("");
            }

        }
    }
}

С тех пор я узнал, что https://stackoverflow.com/a/10380448/4462371, вероятно, является более правильным техническим объяснением.