"Le type n'est pas prévu et aucun contrat ne peut être déduit: erreur Leap.Vector". en utilisant le sérialiseur Protobuf-net

Question

Je suis en train de développer une application qui utilise le dispositif de mouvement de saut et qui sera implémentée en utilisant C#, mon problème est que je veux stocker la liste qui contient les vecteurs dans ma base de données. J'ai donc pensé à une solution de transformation du vecteur en un tableau de flottants, le problème est que chaque liste contient un maximum et un minimum de 300 valeurs (stocker cela dans la base de données prend beaucoup de temps).

J'ai donc cherché d'autres moyens possibles de stockage et j'ai fini sur le sujet de la sérialisation .net. J'avais essayé d'implémenter la sérialisation .net intégrée. Pensé que cela a fonctionné, mais encore une fois il aura fallu environ une minute de sérialiser la liste. Donc une autre solution proposée sur le sujet est d'utiliser le protobuf-net. donc je l'avais essayé et installé en utilisant le programme d'installation du paquet nuget. Et a fini avec cette fonction (copié de la solution Fastest way to serialize and deserialize .NET objects)

public static byte[] Serialize(List<Vector> tData) 
{ 
    using (var ms = new MemoryStream()) 
    { 
     ProtoBuf.Serializer.Serialize(ms, tData); 
     return ms.ToArray(); 
    } 
} 

public static List<Vector> Deserialize(byte[] tData) 
{ 
    using (var ms = new MemoryStream(tData)) 
    { 
     return ProtoBuf.Serializer.Deserialize<List<Vector>>(ms); 
    } 
} 

Mais l'exécution du code me conduire à l'erreur indiqué ci-dessus (le titre).

Je pense que l'erreur se produira à: ProtoBuf.Serializer.Serialize(ms, tData);

Answer 1

@dbc a déjà lié à un code similaire re Point3D, mais je me demande si toute sérialiseur est nécessaire ici. Cela semble assez simple juste cru (note que j'ai supposé que float est le type de données sous-jacente ici, sinon, il suffit de changer tous les sizeof(float) et float* du type correct):

static unsafe byte[] Serialize(List<Vector> vectors) 
{ 
    var arr = new byte[3 * sizeof(float) * vectors.Count]; 
    fixed(byte* ptr = arr) 
    { 
     var typed = (float*)ptr; 
     foreach(var vec in vectors) 
     { 
      *typed++ = vec.X; 
      *typed++ = vec.Y; 
      *typed++ = vec.Z; 
     } 
    } 
    return arr; 
} 
static unsafe List<Vector> Deserialize(byte[] arr) 
{ 
    int count = arr.Length/(3 * sizeof(float)); 
    var vectors = new List<Vector>(count); 
    fixed (byte* ptr = arr) 
    { 
     var typed = (float*)ptr; 
     for(int i = 0; i < count; i++) 
     { 
      var x = *typed++; 
      var y = *typed++; 
      var z = *typed++; 
      vectors.Add(new Vector(x, y, z)); 
     }    
    } 
    return vectors; 
} 

Si vous êtes vraiment courageux, vous pouvez également essayer de vider les données sous-jacentes directement plutôt que de copier les champs manuellement; cela vaut la peine d'essayer si sizeof(Vector) est exactement 3 * sizeof(float) (ou quel que soit le type sous-jacent).