多消息设计模式C#的JSON反序列化？

Question

我有一个 .net 应用程序在后台运行并侦听 Kafka 消息的用例。我将收到来自 Kafka 的各种有效载荷/消息。每个有效负载具有不同的结构并包含不同的项目。对于每个有效负载，我们必须将其反序列化为自己的实体（并不总是一对一映射，在某些情况下有效负载到实体可能存在一些映射逻辑），每个实体在数据库中都有自己的表。所以，在反序列化之后，这些实体必须保存在数据库中，同时发送到另一个 Kafka 主题。

总的来说，我将整个流程分为维护 SRP 的 3 个部分。一是反序列化，二是数据库保存，三是Kafka。

我目前正在实现反序列化，如下所示：

第一个有效载荷示例：

{
   "type":"fuel",
   "data":{
      "fueltype":"petrol",
      "mileage":23.76,
      "tankcapacity":37
   }
}

{
   "type":"engine",
   "data":{
      "enginetype":"K series",
      "maxpower":88.50,
      "displacement":1197
   }
}

因此这些消息使用 type

进行区分

对于我想为每种类型使用单独的解析器的代码

public interface IJsonParser
    {
        Payload Parse(dynamic data);
    }

 public class FuelParser : IJsonParser
    {
        public Payload Parse(dynamic payload)
        {
            Fuel f = new Fuel();
            f.Mileage = (float)payload.data.mileage;
            return f;
        }
    }

    public class EngineParser : IJsonParser
    {
        public Payload Parse(dynamic data)
        {
            Engine e = new Engine();
            return e;
        }
    }



public class Payload
    {
        public int Id { get; set; }
    }

 public class Fuel : Payload
    {
        public string FuelType { get; set; }
        public float Mileage { get; set; }
        public int TankCapacity { get; set; }
    }

 public class Engine : Payload
    {
        public string EngineType { get; set; }
        public float MaxPower { get; set; }
        public int Displacement { get; set; }
    }
 


 public static class JsonParserFactory
    {
        public static IJsonParser GetJsonParser(string type)
        {
            switch (type)
            {
                case "fuel":
                    return new FuelParser();
                case "engine":
                    return new EngineParser();
                default:
                    return null;
            }
        }
    }

string message = "{\r\n\t\"type\": \"fuel\",\r\n\t\"data\":\r\n\t\t{\r\n\t\t\t\"fueltype\": \"petrol\",\r\n\t\t\t\"mileage\": 23.76,\r\n\t\t\t\"tankcapacity\": 37\r\n\t\t}\r\n}";
            dynamic data = JsonConvert.DeserializeObject<object>(message);

            IJsonParser parser = JsonParserFactory.GetJsonParser(data.type.ToString());
            var model = parser.Parse(data);// This model will then be saved in DB as well as sent to another Kafka topic which is the 2nd and 3rd part of the flow.

因此，根据我创建的类型，我创建了一个正在创建单个解析器的工厂。

如果这是一个好的设计，我只是想要建议。我唯一担心的是，未来会有多种类型的有效载荷出现，这将增加解析器的数量。

有什么建议吗？

Answer 1

也可以使用接受类型的DeserializeObject 方法。这样你就不需要编写任何类型特定的解析器，你只需要找出一个类型并将它提供给那个方法。像这样的：

public Payload GetPayload(string type, string message)
    {
        switch (type)
        {
            case "fuel":
                return JsonConvert.DeserializeObject(message, typeof(Fuel));
            case "engine":
                return JsonConvert.DeserializeObject(message, typeof(Engine));
            default:
                return null;
        }
    }

然后您可以使用 JsonProperties 属性（基本上是映射）来装饰您的实体类，如 here 所示（加上使用该转换器）：

[JsonConverter(typeof(JsonPathConverter))]
class Fuel : Payload
{
   [JsonProperty("data.fueltype")]
   public string FuelType{ get; set; }

   [JsonProperty("data.mileage")]
   public float Mileage { get; set; }
}



string message = "{\r\n\t\"type\": \"fuel\",\r\n\t\"data\":\r\n\t\t{\r\n\t\t\t\"fueltype\": \"petrol\",\r\n\t\t\t\"mileage\": 23.76,\r\n\t\t\t\"tankcapacity\": 37\r\n\t\t}\r\n}";
var type = GetMessageType(); // get type from message i.e. with JObject
var payload = GetPayload(type, message);