FlatBuffers KeyValuePair Datentyp und Schemadefinition

Question

Ich habe ein Objekt, das ich über das Netzwerk über TCP senden muss. Ich hatte das funktioniert gut, aber ich habe jetzt auf meine Implementierung erweitert und habe Probleme bei der Ausarbeitung meiner FlatBuffer Schema.

Das Objekt gesendet werden soll, ist dies:

public enum PredictionMethod 
{ 
    Distance = 1, 
    NGram = 2, 
} 

NGramPrediction sieht wie folgt aus::

public class Prediction 
{ 
    public PredictionMethod PredictionMethod { get; set; } 
    public NGramPrediction NGramPrediction { get; set; } 
    public DistancePrediction DistancePrediction { get; set; } 
    public int NGramOrder { get; set; } 
} 

PredictionMethod eine Enumeration ist

public class NGramPrediction 
{ 
    public KeyValuePair<char, int> Gram { get; set; } 
    public double Probability { get; set; } 
    public string Pattern { get; set; } 
    private int Total { get; set; } 
    private int Order { get; set; } 

    public NGramPrediction(Gram gram) 
    { 
     Total = gram.Total(); 
     var orderedKeyPosibilities = gram.Posibilities.OrderByDescending(x => x.Value); 

     Gram = orderedKeyPosibilities.First(); 

     Pattern = gram.Pattern; 
     Probability = (double)Gram.Value/Total; 

     Order = Pattern.Length; 
    } 
} 

Gram sieht wie folgt aus:

public class DistancePrediction 
{ 
    public IIRVector3 Velocity { get; set; } 
    public float DeltaTime { get; set; } 
    public IIRVector3 Position { get; set; } 
} 

und schließlich IIRVector3 sieht wie folgt aus:

public class IIRVector3 
{ 
    public IIRVector3() 
    { 
     X = 0; 
     Y = 0; 
     Z = 0; 
    } 
    public float X { get; set; } 
    public float Y { get; set; } 
    public float Z { get; set; } 
} 

zu definieren Ich versuche

public class Gram 
{ 
    public string Pattern { get; set; } 

    public Dictionary<char, int> Posibilities { get; set; } 

    public Gram(List<char> posibilities, int initialValue = 0) 
    { 
     Posibilities = new Dictionary<char, int>(); 
     foreach (var posibility in posibilities) 
     { 
      Posibilities.Add(posibility, initialValue); 
     } 
    } 

    public int Total() 
    { 
     var keys = Posibilities.Keys; 
     var total = 0; 
     foreach (var key in keys) 
     { 
      var value = Posibilities[key]; 
      total += value; 
     } 
     return total; 
     // return keys.Sum(key => Posibilities[key]); 
    } 

} 

DistancePrediction wie folgt aussieht Mein Schema für FlatBuffers:

enum FBPredictionMethod 
{ 
    Distance = 1, 
    NGram = 2 
} 

struct FBIIRVector3 
{ 
    X:float; 
    Y:float; 
    Z:float; 
} 

table FBDistancePrediction 
{ 
    Velocity:FBIIRVector3; 
    DeltaTime:float; 
    Position:FBIIRVector3; 
} 

table FBGram 
{ 
    Pattern:string; 
    Possibilities: ???? 
} 

table FBNGramPrediction 
{ 
    Gram: ???? 
    Probability:float; 
    Pattern:string; 
    Total:short; 
    Order:short; 
} 

table FBPrediction 
{ 
    PredictionMethod:FBPredictionMethod; 
    NGramPrediction:FBNGramPrediction; 
    DistancePrediction:FBDistancePrediction; 
    NGramOrder:short; 
} 

root_type FlatServerToClientMessage; 

Ich denke, alles korrekt aussieht, aber ich habe keine Ahnung, was für die Wörterbücher zu tun ...

FBGram.Possibilities sollte ein Dictionary<char, int> und FBGram seinKeyValuePair<char, int> sein sollte.

Hinweis: Gram Konstruktor nimmt ein List<char> und ein int als Parameter, während der Konstruktor für NGramPrediction ein Gram als Parameter annimmt.

Könnte mir bitte jemand mit meinem Schema helfen?

Answer 1

Die KeyValuePair sollte einfach sein .. entweder nur speichern sie als zwei separate Felder oder ein struct KeyValuePair { key:byte; value:int; }

Die Dictionary verwenden könnte als Possibilities:[KeyValuePair] gespeichert werden (die gleiche Struktur verwenden). Wenn Sie Platz sparen möchten, wenn Possibilities kann groß sein, dann PossibilityKeys:[byte] und PossibilityValues:[int] wird ein wenig kompakter, aber schwerer zu lesen/schreiben.