将特定枚举反序列化为 Json.Net 中的 system.enum

我有一个相当通用的“规则”类，我用它来驱动我正在编写的分析引擎的行为：

public class Rule
{
    /// <summary>
    /// The general rule type.
    /// </summary>
    public RuleType RuleType { get; set; }

    /// <summary>
    /// The human-readable description of the rule.
    /// </summary>
    public string RuleDescription { get; set; }

    /// <summary>
    /// The integer magnitude of the rule, if applicable.
    /// </summary>
    public int? RuleInt { get; set; }

    /// <summary>
    /// The boolean sign associated with the rule, if applicable.
    /// </summary>
    public bool? RuleBool { get; set; }

    /// <summary>
    /// The enum flag associated with the rule, if applicable.  CAN be null.
    /// </summary>
    public System.Enum RuleFlagEnum { get; set; }

    /// <summary>
    /// A dumping ground for any other random crap I've failed to account for at this point in time.
    /// </summary>
    public object RuleObject { get; set; }
}

RuleType 是一个特定的枚举，如下所示：

public enum RuleType
{
    Invalid,
    ModifyDifficulty,
    StrengthChange,
    ColorChange,
    SignChange
}

使用 Json.NET，序列化和反序列化都很好。

然而，RuleEnum 给我带来了问题。无论是使用默认的枚举序列化还是字符串枚举序列化，都没有提供枚举的具体类型。因此，在反序列化过程中，我留下了System.Enum和一个字符串值，这完全没有帮助。

这是序列化的示例，以展示我在说什么：

{
   "RuleType": "SignChange",
   "RuleDescription": "Strength 1 Inversion Gate",
   "RuleInt": 1,
   "RuleFlagEnum": "Negative"
}

在本例中，RuleFlagEnum 指的是枚举：

public enum SignChange
{
    Zero,
    Positive,
    Negative
}

我尝试过使用所有的TypeNameHandlingJson.NET 中的选项。他们只在对象上添加类型提示，这对 RuleFlagEnum 没有帮助，因为它在技术上是一个原语。

我真的非常想将枚举保留在 System.Enum 中，这样我们就可以加载任何任意枚举，以便以后通过规则类型进行解释，因此整个事情更具可扩展性。这可能吗？

这里的困难在于System.Enum https://msdn.microsoft.com/en-us/library/system.enum%28v=vs.110%29.aspx是一个抽象类，因此不可能将未知具体类型的值反序列化为此类类型。相反，人们需要在 JSON 中的某处拥有特定类型信息，但是 Json.NET 会序列化一个enum作为字符串或整数（取决于是否StringEnumConverter http://www.newtonsoft.com/json/help/html/T_Newtonsoft_Json_Converters_StringEnumConverter.htm被应用）——但不是作为对象，因此没有机会多态性"$type"财产 http://www.newtonsoft.com/json/help/html/SerializeTypeNameHandling.htm待补充。

解决方案是，在序列化时，序列化一个可以传达具体类型信息的通用包装类：

public abstract class TypeWrapper
{
    protected TypeWrapper() { }

    [JsonIgnore]
    public abstract object ObjectValue { get; }

    public static TypeWrapper CreateWrapper<T>(T value)
    {
        if (value == null)
            return new TypeWrapper<T>();
        var type = value.GetType();
        if (type == typeof(T))
            return new TypeWrapper<T>(value);
        // Return actual type of subclass
        return (TypeWrapper)Activator.CreateInstance(typeof(TypeWrapper<>).MakeGenericType(type), value);
    }
}

public sealed class TypeWrapper<T> : TypeWrapper
{
    public TypeWrapper() : base() { }

    public TypeWrapper(T value)
        : base()
    {
        this.Value = value;
    }

    public override object ObjectValue { get { return Value; } }

    public T Value { get; set; }
}

然后在序列化类时使用序列化包装器：

    /// <summary>
    /// The enum flag associated with the rule, if applicable.  CAN be null.
    /// </summary>
    [JsonIgnore]
    public System.Enum RuleFlagEnum { get; set; }

    [JsonProperty("RuleFlagEnum", TypeNameHandling = TypeNameHandling.All)]
    TypeWrapper RuleFlagEnumValue
    {
        get
        {
            return RuleFlagEnum == null ? null : TypeWrapper.CreateWrapper(RuleFlagEnum);
        }
        set
        {
            if (value == null || value.ObjectValue == null)
                RuleFlagEnum = null;
            else
                RuleFlagEnum = (Enum)value.ObjectValue;
        }
    }

这会生成如下 JSON：

{
  "RuleType": "ModifyDifficulty",
  "RuleFlagEnum": {
    "$type": "Question31351262.TypeWrapper`1[[Question31351262.MyEnum, MyApp]], MyApp",
    "Value": "Two, Three"
  },
}