"Typ wird nicht erwartet, und kein Vertrag kann abgeleitet werden: Leap.Vector" Fehler. Verwenden von Protobuf-net Serializer

Question

Ich bin dabei, eine Anwendung zu entwickeln, die das Schaltgerät verwendet und mit C# implementiert wird, mein Problem ist, dass ich die Liste speichern möchte, die die Vektoren in meiner Datenbank enthält. Also habe ich über eine Lösung des Transformierens des Vektors in ein Array von Gleitkommazahlen nachgedacht. Das Problem besteht darin, dass jede Liste ein Maximum und ein Minimum von 300 Werten enthält (das Speichern in der Datenbank kostet viel Zeit).

So habe ich nach anderen Möglichkeiten der Speicherung suchen und ich endete auf dem Thema. NET Serialisierung. Ich hatte versucht, die integrierte .net-Serialisierung zu implementieren. Dachte, es hat geklappt, aber noch einmal dauert es ungefähr eine Minute, um die Liste zu serialisieren. Eine andere Lösung, die zu diesem Thema vorgeschlagen wird, ist die Verwendung des Protobuf-Netzes. also habe ich es versucht und installiert mit dem nugget-paketinstallationsprogramm. Und endete mit dieser Funktion nach oben (aus der Lösung kopiert 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); 
    } 
} 

aber den Code ausgeführt wird mich oben (der Titel) angegeben zu dem Fehler führen.

denke ich, wird der Fehler passieren bei: ProtoBuf.Serializer.Serialize(ms, tData);

Answer 1

@dbc bereits zu ähnlichen Code re Point3D verknüpft hat, aber ich frage mich, ob jede Serializer hier gebraucht wird. Das sieht einfach genug, nur roh tun (beachten Sie, ich bin davon ausgegangen, dass float die zugrunde liegenden Datentyp hier ist, wenn nicht, nur alle sizeof(float) und float* auf den richtigen Typ aus):

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; 
} 

Wenn Sie sind wirklich mutig, Sie könnten auch versuchen, die zugrunde liegenden Daten direkt Dumping lieber als die Felder manuell kopieren; das wäre einen Versuch wert, wenn sizeof(Vector) genau 3 * sizeof(float) (oder was auch immer der zugrunde liegende Typ ist) ist.