如何避免反序列化无效枚举项时出现异常？

Question

为了简单起见，我将使用 Fruit 来展示我的示例代码。事实上我正在做一些更有意义的事情（我们希望如此）。假设我们有一个枚举：

public enum FruitType
{
    Apple,
    Orange,
    Banana
}

和一个类：

[Serializable]
public class Fruit
{
    public FruitType FruitType { get; set; }
    public Fruit(FruitType type)
    {
        this.FruitType = type;
    }
}

我们可以对其进行序列化和反序列化。现在，让我们修改枚举，使其成为现在的样子：

public enum FruitType
{
    GreenApple,
    RedApple,
    Orange,
    Banana
}

当反序列化先前序列化的对象时，您会收到 System.InvalidOperation 异常，因为 Apple （原始枚举项）是无效。该对象不会被反序列化。

我能够解决此问题的一种方法是在序列化时为 Fruit 类中的 FruitType 属性指定一个不同的名称，如下所示：

    [XmlElement(ElementName = "Mode")]
    public FruitType FruitType { get; set; }

现在，在反序列化期间，旧的属性将被忽略，因为找不到它。我想知道是否有一种方法可以在反序列化期间忽略/跳过无效的枚举项，以便不会引发异常并且对象仍然被反序列化。

Answer 1

保留 Apple 并使用 ObsoleteAttribute 对其进行标记。这样，任何使用 Apple 的代码都会生成编译器警告。

Answer 2

我自己一直在寻找类似的答案，并编写此代码以在 XML 包含无效枚举值时捕获异常。它删除该元素，并尝试再次反序列化。如果该元素是必需的，您仍然会遇到异常。它并不完美，但应该能让你大部分到达你想去的地方

    private const string XmlError = "There is an error in XML document ";
    private const string InstanceValidationError = "Instance validation error:";
    private static readonly Regex XmlErrorRegex = new Regex("There is an error in XML document \\((\\d+), (\\d+)\\).");
    private static readonly Regex InstanceValidationErrorRegex = new Regex("Instance validation error: '(\\S+)' is not a valid value for (\\S+).");
    private const string TagFinderString = "\\>{0}\\</(\\S+)\\>";

    /// <summary>
    /// Helper method to deserialize xml message
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="message"></param>
    /// <returns></returns>
    public T Deserialize(string message)
    {
        var result = default(T);
        if (!string.IsNullOrEmpty(message))
        {
            using (var reader = new StringReader(message))
            {
                try
                {
                    result = (T)_serializer.Deserialize(reader);
                }
                catch (InvalidOperationException ex)
                {
                    if (ex.Message.StartsWith(XmlError))
                    {
                        if(ex.InnerException != null && ex.InnerException.Message.StartsWith(InstanceValidationError))
                        {
                            var instanceValidationErrorMatches = InstanceValidationErrorRegex.Matches(ex.InnerException.Message);
                            if (instanceValidationErrorMatches.Count > 0)
                            {
                                var locationMatches = XmlErrorRegex.Matches(ex.Message);
                                var startIndex = GetStartIndex(message, locationMatches);
                                var match = instanceValidationErrorMatches[0];
                                if(match.Groups.Count > 0)
                                {
                                    var toRemove = GetToRemove(message, match, startIndex);

                                    return Deserialize(message.Replace(toRemove, string.Empty));
                                }
                            }
                        }
                    }
                }
            }
        }
        return result;
    }

    private static string GetToRemove(string message, Match match, int startIndex)
    {
        var value = match.Groups[1];
        var tagFinder = new Regex(string.Format(TagFinderString, value));
        var tagFinderMatches = tagFinder.Matches(message.Substring(startIndex));
        var tag = tagFinderMatches[0].Groups[1];

        return string.Format("<{0}>{1}</{0}>", tag, value);
    }

    private static int GetStartIndex(string message, MatchCollection locationMatches)
    {
        var startIndex = 0;
        if (locationMatches.Count > 0)
        {
            var lineNumber = int.Parse(locationMatches[0].Groups[1].Value);
            var charIndex = int.Parse(locationMatches[0].Groups[2].Value);
            using (var locationFinder = new StringReader(message))
            {
                for (var i = 1; i < lineNumber; i++)
                {
                    startIndex += locationFinder.ReadLine().Length;
                }
            }
            startIndex += charIndex;
        }
        return startIndex;
    }

Answer 3

我发布了一个类似问题并且还没有找到一个简单的方法来捕获反序列化器在XML文件中遇到Apple时抛出的异常。我可以在反序列化期间捕获丢失属性或元素的一堆其他异常，但不能捕获无效的枚举值。无效的枚举值（在你的例子中是苹果）让我无法进行反序列化。

一种可能的解决方案是实施 Fruit 类上的 IXMLSerialized。当 IXMLSerailable 时。 ReadXML() 方法由反序列化器调用，您必须查看传递给您的内容。当值为“Apple”时，根据某种逻辑将枚举设置为 GreenApple 或 RedApple。