Question

我知道这是一个热门话题，我已经进行了广泛的研究而没有找到问题的答案。

我有一个基类IntroductionAction和两个派生类IntroductionActionComplex和IntroductionActionSimple。我有一个IntroductionAction对象列表，我已添加了两个派生类型的对象。我的课程如下：

[XmlInclude(typeof(IntroductionActionComplex))]
[XmlInclude(typeof(IntroductionActionSimple))]
public class IntroductionAction
{
    public IntroductionAction() { }
}

public class IntroductionActionComplex : IntroductionAction
{
    [XmlIgnore]
    public string name { get; set; }

    [XmlElement(ElementName = "QuestionString")]
    public string question { get; set; }

    [XmlElement(ElementName = "AnswerString")]
    public List<string> answerStrings { get; set; }

    public IntroductionActionComplex()
    {
        name = string.Empty;
        question = null;
        answerStrings = new List<string>();
    }
}

public class IntroductionActionSimple : IntroductionAction
{
    [XmlIgnore]
    public string name { get; set; }

    [XmlText]
    public string Value { get; set; }

    public IntroductionActionSimple()
    {
        Value = string.Empty;
    }
}

然后我按如下方式创建List

[XmlElement("IntroductionAction")]
public List<IntroductionAction> introductionActions { get; set; }

我正在使用XmlSerializer，所有内容都正确序列化。这是列表的结果XML，其中包含每个派生类中的一个是正确的。

<IntroductionAction>
  <QuestionString>
    test
  </QuestionString>
  <AnswerString>
    test
  </AnswerString>
  <AnswerString>
    test
  </AnswerString>
</IntroductionAction>
<IntroductionAction>
  test
</IntroductionAction>

这个XML文件将进入一个设备，该设备不会将其作为XML读取，而只是搜索标签并执行它需要做的任何工作，因此该文件不能包含任何XSI或XSD标记，缩进等通常与正确的XML相关联。

我的反序列化代码很简单：

public static T Deserialize_xml_Config<T>(string file1, T obj)
{
   XmlSerializer deserializer = new XmlSerializer(obj.GetType());
   using (TextReader reader = new StreamReader(file1))
   {
      return (T)deserializer.Deserialize(reader);
   }
}

最后我的问题。当我反序列化时，它被反序列化到基类IntroductionAction而不是派生类。这些IntroductionAction类只是我序列化/反序列化的更大对象的一部分。我已经尝试使基类抽象，因为它不包含任何功能，但我在反序列化时收到错误

指定的类型是abstract：name ='IntroductionAction'

尽管我的XmlIncludes似乎无法找到派生类。

我已尝试将类型添加到序列化程序但不起作用。

非常感谢任何帮助。

编辑：我的意思是将类型添加到序列化程序

XmlSerializer deserializer = new XmlSerializer(obj.GetType(), new Type [] { typeof(IntroductionActionComplex), typeof(IntroductionActionSimple) });
using (TextReader reader = new StreamReader(file1))
{
   return (T)deserializer.Deserialize(reader);
}

我也尝试使用XmlAttributeOverrides：

XmlAttributeOverrides attrOverrides = new XmlAttributeOverrides();
var attrs = new XmlAttributes();
XmlElementAttribute attr = new XmlElementAttribute();
attr.ElementName = "IntroductionAction";
attr.Type = typeof(IntroductionActionComplex);
attrs.XmlElements.Add(attr);
attr.ElementName = "IntroductionAction";
attr.Type = typeof(IntroductionActionSimple);
attrs.XmlElements.Add(attr);
attrOverrides.Add(typeof(IntroductionAction), "IntroductionAction", attrs);

XmlSerializer deserializer = new XmlSerializer(obj.GetType(), attrOverrides);
using (TextReader reader = new StreamReader(file1))
{
   return (T)deserializer.Deserialize(reader);
}

Answer 1

我认为你非常接近。下面是基于派生类类型保存和加载XML文件的完整示例。这将节点保存为派生类型本身，因此重新加载将保留所需类型，而不是转换回基本类型。您可能需要添加异常处理，这只是一个快速的解决方案。我没有更改您的基础IntroductionAction或派生的IntroductionActionComplex / IntroductionActionSimple类。

public class RootNode
{
   [XmlElement("IntroductionAction")]
   public List<IntroductionAction> introductionActions { get; set; }

   public RootNode()
   {
      introductionActions = new List<IntroductionAction>();
   }

   private static XmlAttributeOverrides GetXmlAttributeOverrides()
   {
      XmlAttributeOverrides xml_attr_overrides = new XmlAttributeOverrides();
      XmlAttributes xml_attrs = new XmlAttributes();
      xml_attrs.XmlElements.Add(new XmlElementAttribute(typeof(IntroductionActionComplex)));
      xml_attrs.XmlElements.Add(new XmlElementAttribute(typeof(IntroductionActionSimple)));
      xml_attr_overrides.Add(typeof(RootNode), "introductionActions", xml_attrs);
      return xml_attr_overrides;
   }

   // Add exception handling
   public static void SaveToFile(RootNode rootNode, string fileName)
   {
      using (MemoryStream mem_stream = new MemoryStream())
      {
         XmlSerializer serializer = new XmlSerializer(rootNode.GetType(), RootNode.GetXmlAttributeOverrides());
         serializer.Serialize(mem_stream, rootNode);

         using (BinaryWriter output = new BinaryWriter(new FileStream(fileName, FileMode.Create)))
         {
            output.Write(mem_stream.ToArray());
         }
      }
   }

   // Add exception handling
   public static RootNode LoadFromFile(string fileName)
   {
      if (File.Exists(fileName))
      {
         using (FileStream file = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
         {
            using (TextReader reader = new StreamReader(file))
            {
               XmlSerializer serializer = new XmlSerializer(typeof(RootNode), RootNode.GetXmlAttributeOverrides());
               return (RootNode)serializer.Deserialize(reader);
            }
         }
      }
      return null;
   }
}

测试程序：

internal class Program
{
   private static void Main(string[] args)
   {
      RootNode obj = new RootNode();
      obj.introductionActions.Add(new IntroductionActionComplex() { question = "qTest", answerStrings = { "aTest1", "aTest2" }, name = "aName1" });
      obj.introductionActions.Add(new IntroductionActionSimple() { name = "aName2", Value = "aValue" });

      RootNode.SaveToFile(obj, "Test.xml");

      RootNode obj2 = RootNode.LoadFromFile("Test.xml");
   }
}

Xml被反序列化为基类而不是派生类

1 个答案: