Ottieni dati dall'array di byte

Penso che uno schema generale per questo sia il seguente

public interface IData
{
    Type Type {get;set;}
    byte[] Data {get;set;}
}

e poi molti:

public interface IDataConverter<T>
{
    T Convert(byte[] data);
    bool CanConvert(Type type);
}

Quindi puoi creare un IDataConverter per qualunque tipo tu voglia, e il convertitore ha una lista di questi che attraversa, chiamando CanConvert. Se restituisce true, chiama la funzione Converti e restituisce il risultato

class Converter
{
    private List<object> converters;
    public void AddConverter<T>(IDataConverter<T> converter)
    {
        this.converters.Add(converter);
    }
    public T Convert<T>(IData data) where T:class
    {
        var ret = converters
                .Select(i => ((dynamic)i))
                .Where(i => i.CanConvert(data.Type))
                .FirstOrDefault()?
                .Convert(data.Data)
                ;

        return ret as T;
    }
}

Modifica: come si può vedere lo shoehorning nel tipo generico è difficile. Probabilmente stai meglio usando lo stesso modello ma solo restituendo l'oggetto

Se hai bisogno di fare un comportamento diverso in fase di esecuzione a seconda del tipo di dati, non sarai in grado di evitare un qualche tipo di commutazione, anche se questo non deve essere letteralmente un'istruzione switch.

Per i dati stessi, il secondo ha il vantaggio che puoi passare il DynamicData (o qualsiasi altra cosa tu chiami la coppia Tipo / oggetto) più avanti per essere gestito più tardi, ma avrei anche un metodo diretto per quando il il tipo è noto:

DynamicData GiveMeData();
T GiveMeData<T>(); 

Mentre una funzione generale per ottenere i dati non può fare più di questo, è possibile modificare i consumatori dei dati per gestire i diversi tipi in modo dinamico. Ad esempio:

interface IDataConsumer
{
   IResult Consume(DynamicData data);
}

...

Dictionary<Type,IDataConsumer> consumers = ...;
var data = dataSource.GiveMeData();
var result = consumers[data.DataType].Consume(data);

Sotto il cofano, in pratica, è ancora un'affermazione, ma è molto più facile da aggiungere in futuro.

E, naturalmente, se uno qualsiasi dei tipi di dati condivide la funzionalità, puoi farli implementare un'interfaccia comune e gestirli tutti insieme.