FlatBuffers KeyValuePair 数据类型和架构定义

Question

我有一个需要使用 TCP 通过网络发送的对象。我的工作正常，但我现在已经扩展了我的实现，并且无法确定如何定义我的 FlatBuffer 架构。

要发送的对象是这样的：

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

PredictionMethod 是一个枚举：

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

NGramPrediction 如下所示：

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

克看起来像这样：

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 看起来像这样：

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

最后，IIRVector3 看起来像这样：

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

我正在尝试为 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;

我认为一切看起来都是正确的，但我不知道如何处理字典...

FBGram.Possibilities 应该是 Dictionary<char, int>，FBGram 应该是 KeyValuePair<char, int>。

注意：Gram 的构造函数以List<char> 和int 作为参数，而NGramPrediction 的构造函数以Gram 作为参数。

有人可以帮我解决我的架构吗？

Answer 1

KeyValuePair 应该很简单.. 要么将它们存储为两个单独的字段，要么使用 struct KeyValuePair { key:byte; value:int; }

Dictionary 可以存储为Possibilities:[KeyValuePair]（使用相同的结构）。如果你想在Possibilities 很大的情况下节省空间，那么PossibilityKeys:[byte] 和PossibilityValues:[int] 会更紧凑一些，但更难读/写。