Json 将多个值反序列化为单个属性

我有一个JSON响应，其中包括几个标志：

{"df":1,"dr":0,"pf":0,"pr":0,"ft":0,"rt":1}

我想将其反序列化为标志枚举：

public class Foo {
    public Doors Doors { get; set; }
    public Trunk Trunks { get; set; }
}

df、dr、pf、pr应反序列化为Doors标志枚举，而ft、rt应反序列化为中继。我希望这是定制代码来做出决定。我要找的是能让我说：

[JsonProperty("df,dr,pf,pr"), JsonConverter(typeof(DoorsConverter))]
public Doors Door { get; set; }

---

这将使我能够根据这些价值来处理房地产的建设。这类事情是否存在，还是我一直在将单个属性推送到非公共字段并在事后构建属性？

最近添加到JSON.NET的内容与我们在WCF数据契约中得到的内容类似。有了它，我可以添加一个额外的属性和方法来处理它：

[JsonExtensionData]
public IDictionary<string, JToken> ExtensionData;

[OnDeserialized]
private void OnDeserialized(StreamingContext context)
{
    Doors = ExtensionData.ContainsKey("df") && Convert.ToBoolean(Convert.ToInt16(ExtensionData["df"]))
        ? Doors | Door.DriverSideFront
        : Doors & ~Door.DriverSideFront;
    Doors = ExtensionData.ContainsKey("dr") && Convert.ToBoolean(Convert.ToInt16(ExtensionData["dr"]))
        ? Doors | Door.DriverSideRear
        : Doors & ~Door.DriverSideRear;
    Doors = ExtensionData.ContainsKey("pf") && Convert.ToBoolean(Convert.ToInt16(ExtensionData["pf"]))
        ? Doors | Door.PassengerSideFront
        : Doors & ~Door.PassengerSideFront;
    Doors = ExtensionData.ContainsKey("pr") && Convert.ToBoolean(Convert.ToInt16(ExtensionData["pr"]))
        ? Doors | Door.PassengerSideRear
        : Doors & ~Door.PassengerSideRear;

    Trunks = ExtensionData.ContainsKey("ft") && Convert.ToBoolean(Convert.ToInt16(ExtensionData["ft"]))
        ? Trunks | Trunk.Front
        : Trunks & ~Trunk.Front;
    Trunks = ExtensionData.ContainsKey("rt") && Convert.ToBoolean(Convert.ToInt16(ExtensionData["rt"]))
        ? Trunks | Trunk.Rear
        : Trunks & ~Trunk.Rear;

    ExtensionData.Remove("dt");
    ExtensionData.Remove("dr");
    ExtensionData.Remove("pf");
    ExtensionData.Remove("pr");
    ExtensionData.Remove("ft");
    ExtensionData.Remove("rt");
}

[JsonExtensionData]
公共词典扩展数据；
[已序列化]
私有void已序列化（StreamingContext上下文）
{
Doors=ExtensionData.ContainsKey（“df”）和&Convert.ToBoolean（Convert.ToInt16（ExtensionData[“df”]））
？门|门驱动装置前
：Doors&~Door.DriverSideFront；
Doors=ExtensionData.ContainsKey（“dr”）和&Convert.ToBoolean（Convert.ToInt16（ExtensionData[“dr”]））
？门|门驱动装置
：Doors&~Door.DriverSideRear；
Doors=ExtensionData.ContainsKey（“pf”）和&Convert.ToBoolean（Convert.ToInt16（ExtensionData[“pf”]））
？门|门。乘客前方
：Doors&~Door.PassengerSideFront；
Doors=ExtensionData.ContainsKey（“pr”）和&Convert.ToBoolean（Convert.ToInt16（ExtensionData[“pr”]））
？车门|车门。乘客车门
：Doors&~Door.passengersideriar；
Trunks=ExtensionData.ContainsKey（“ft”）和&Convert.ToBoolean（Convert.ToInt16（ExtensionData[“ft”]））
？行李箱|行李箱。前部
：Trunks和~Trunk.Front；
Trunks=ExtensionData.ContainsKey（“rt”）和&Convert.ToBoolean（Convert.ToInt16（ExtensionData[“rt”]））
？后备箱|后备箱
：后备箱和后备箱；
扩展数据删除（“dt”）；
扩展数据删除（“dr”）；
ExtensionData.Remove（“pf”）；
ExtensionData.Remove（“pr”）；
扩展数据删除（“ft”）；
ExtensionData.Remove（“rt”）；
}

---

这适用于读取场景。还没有研究过写场景以及它将如何改变情况。

我同意@JeffMercado的观点，处理这个问题的最佳方法是创建一个处理整个类的自定义转换器。您在评论中说，创建这样一个转换器是因为您不想编写代码来处理所有其他类属性（问题中未显示），因为它们不需要任何特殊处理。为此，我提出了一个转换器的想法，它将使用JSON.Net的常用机制对所有标准属性进行序列化/反序列化，然后专门处理

Doors

和

Trunks

enum字段。因为我不知道你们的其他财产叫什么，所以我只是编了一些与汽车有关的财产。我还将你的

Foo

类重命名为

Car

，以符合该主题

以下是此示例的类和枚举定义：

public class Car
{
    [JsonIgnore]
    public Door Doors { get; set; }
    [JsonIgnore]
    public Trunk Trunks { get; set; }
    [JsonProperty("make")]
    public string Make { get; set; }
    [JsonProperty("model")]
    public string Model { get; set; }
    [JsonProperty("year")]
    public int Year { get; set; }
    [JsonProperty("MSRP")]
    public decimal MSRP { get; set; }
}

[Flags]
public enum Door 
{
    None = 0,
    DriverSideFront = 1,
    DriverSideRear = 2,
    PassengerSideFront = 4,
    PassengerSideRear = 8 
}

[Flags]
public enum Trunk
{
    None = 0,
    Front = 1, 
    Rear = 2
}

以下是自定义转换器的代码：

public class CarConverter : JsonConverter
{
    private static Dictionary<string, Door> doorMap;
    private static Dictionary<string, Trunk> trunkMap;

    static CarConverter()
    {
        doorMap = new Dictionary<string, Door>();
        doorMap.Add("df", Door.DriverSideFront);
        doorMap.Add("dr", Door.DriverSideRear);
        doorMap.Add("pf", Door.PassengerSideFront);
        doorMap.Add("pr", Door.PassengerSideRear);

        trunkMap = new Dictionary<string, Trunk>();
        trunkMap.Add("ft", Trunk.Front);
        trunkMap.Add("rt", Trunk.Rear);
    }

    public override bool CanConvert(Type objectType)
    {
        return (objectType == typeof(Car));
    }

    public override object ReadJson(JsonReader reader, Type objectType, 
                                    object existingValue, JsonSerializer serializer)
    {
        JObject jo = JObject.Load(reader);
        Car car = jo.ToObject<Car>();
        car.Doors = GetDoors(jo);
        car.Trunks = GetTrunks(jo);
        return car;
    }

    private Door GetDoors(JObject obj)
    {
        Door doors = Door.None;
        foreach (KeyValuePair<string, Door> kvp in doorMap)
        {
            if (obj[kvp.Key].Value<int>() == 1)
            {
                doors |= kvp.Value;
            }
        }
        return doors;
    }

    private Trunk GetTrunks(JObject obj)
    {
        Trunk trunks = Trunk.None;
        foreach (KeyValuePair<string, Trunk> kvp in trunkMap)
        {
            if (obj[kvp.Key].Value<int>() == 1)
            {
                trunks |= kvp.Value;
            }
        }
        return trunks;
    }

    public override void WriteJson(JsonWriter writer, object value, 
                                   JsonSerializer serializer)
    {
        Car car = (Car)value;
        JObject obj = JObject.FromObject(value);
        AddDoors(obj, car.Doors);
        AddTrunks(obj, car.Trunks);
        obj.WriteTo(writer);
    }

    private void AddDoors(JObject obj, Door doors)
    {
        foreach (KeyValuePair<string, Door> kvp in doorMap)
        {
            obj.Add(kvp.Key, ((doors & kvp.Value) != Door.None) ? 1 : 0);
        }
    }

    private void AddTrunks(JObject obj, Trunk trunk)
    {
        foreach (KeyValuePair<string, Trunk> kvp in trunkMap)
        {
            obj.Add(kvp.Key, ((trunk & kvp.Value) != Trunk.None) ? 1 : 0);
        }
    }
}

重要提示：

---

您可能想用

[JsonConverter（typeof（CarConverter））]

装饰

Car

类，但不要这样做。如果您这样做，那么

CarConverter

将无法正常工作：转换器将以递归方式调用自身，直到出现

StackOverflowException

错误。（手动处理所有类属性的转换器不会有此问题。）

您不能（也不应该）尝试通过单个属性转换器将多个属性组合成单个属性，您应该为包含该转换的类创建一个自定义转换器来处理该转换。@JeffMercado-我查看了一个自定义转换类，并对“全有或全无”方法的想法产生了兴趣。在本例中，它是一小部分特殊属性，其他所有属性都是纯JSON。您是否见过一个只选择性地处理特定属性的JsonConverter派生类型的示例？JObject的ReadJson和WriteJson用法是我所缺少的。我在查看文档时担心的是，一旦你走上自定义转换类的路线，你将无法处理所有事情。像这样使用ExtensionData就是我要做的。

static void Q18066528()
{
    string json = @"{""df"":1,""dr"":0,""pf"":0,""pr"":1,""ft"":0,""rt"":1,
       ""make"":""Chevrolet"",""model"":""Corvette"",""year"":2013,""MSRP"":49600}";

    JsonSerializerSettings settings = new JsonSerializerSettings 
    { 
        Converters = new List<JsonConverter> { new CarConverter() } 
    };

    Car car = JsonConvert.DeserializeObject<Car>(json, settings);

    Console.WriteLine("Model: " + car.Model);
    Console.WriteLine("Year: " + car.Year);
    Console.WriteLine("Doors: " + car.Doors);
    Console.WriteLine("Trunks: " + car.Trunks);

    string json2 = JsonConvert.SerializeObject(car, settings);

    Console.WriteLine(json2);
}

Model: Corvette
Year: 2013
Doors: DriverSideFront, PassengerSideRear
Trunks: Rear
{"make":"Chevrolet","model":"Corvette","year":2013,"MSRP":49600.0,"df":1,"dr":0,
"pf":0,"pr":1,"ft":0,"rt":1}