C# 如何使用不断变化的XML

场景：

输入：

• 一种XML文件，其结构在外部团队的支配下不断变化
• 它不是一个格式良好的XML
• 元素标记有时也会更改

所需输出：

• 由应用程序的其他部分使用的预定义类的对象

问题:

• 如何使用固定的类名映射更改的元素标记

C语言

enter code here
ReadIn("input.xml");

public static GbtInfo ReadIn(string path)
    {
        using (XmlReader reader = new XmlTextReader(path))
        {
            reader.ReadToDescendant("SYSTEM");
            return Serializers.ParseNode<GbtInfo>(reader);
        }
    }

public static T ParseNode<T>(XmlReader reader)
{
    Type t = typeof(T);
    return (T)ParseNode(t, reader);
}

public static object ParseNode(Type type, XmlReader reader)
{
    var instance = Activator.CreateInstance(type);

    IXmlSerializable xmlSerializable = instance as IXmlSerializable;
    if (xmlSerializable != null)
    xmlSerializable.ReadXml(reader);
    return instance;
}

public static object ParseNode(string name_space, string elementName, XmlReader reader)
{
    Type t = Type.GetType(name_space + "." + elementName, false, true);
    return ParseNode(t, reader);
}





public void ReadXml(System.Xml.XmlReader reader)
    {
        this.reader = reader;
        string nextElement;
        parent = reader.Name;
        PropertyInfo propertyinfo = null;

        //Setting a flag if the current node is empty.
        bool isEmptyElement = reader.IsEmptyElement;
        //Code that parses the attributes out of the Node.
        if (reader.HasAttributes)
        {
            for (int i = 0; i < reader.AttributeCount; i++)
            {
                reader.MoveToAttribute(i);
                nextElement = Utilities.RemoveSpecialChar(reader.Name);
                propertyinfo = (GetType()).GetProperty(nextElement, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance);
                if (propertyinfo != null)
                    propertyinfo.SetValue(this, reader.Value, null);
                else
                    PrintError(nextElement);


            }
        }
        if (!isEmptyElement)//if the element is not empty get all the children 
        {
            reader.Read();
            Utilities.SkipToContent(reader);
            while (!(reader.Name.Equals(parent) && reader.NodeType == XmlNodeType.EndElement))
            {
                reader.MoveToContent();
                //Case when Node Element is an object type with string 
                if (reader.NodeType == XmlNodeType.Text)
                {
                    propertyinfo = (GetType()).GetProperty("Value", BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance);

                    if (propertyinfo != null)
                        propertyinfo.SetValue(this, reader.Value, null);
                    else
                        PrintError("Value");

                    //Testing Console.WriteLine(nextelement + " => " + reader.Value);
                    reader.Read();
                    Utilities.SkipToContent(reader);
                }
                if (reader.NodeType == XmlNodeType.Element)
                {
                    nextElement = Utilities.RemoveSpecialChar(reader.Name);
                    propertyinfo = (GetType()).GetProperty(nextElement, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance);
                    if (propertyinfo != null)
                    {
                        if (propertyinfo.PropertyType.FullName.Equals("System.String"))
                        {
                            reader.Read();//read to get the text
                            if (reader.NodeType != XmlNodeType.Text)
                                throw new InvalidOperationException("Special Case encountered check XML");
                            propertyinfo.SetValue(this, reader.Value, null);
                            //Testing Console.WriteLine(reader.Value);
                            reader.ReadToNextSibling("dummy");//this will read to the parent end tag
                            reader.Read();
                            Utilities.SkipToContent(reader);
                        }
                        else
                        {

                            System.Collections.IList list = propertyinfo.GetValue(this, null) as System.Collections.IList;
                            if (list != null)
                            {
                                list.Add(Serializers.ParseNode(Namespace, nextElement, reader));

                            }
                            else
                            {
                                propertyinfo.SetValue(this, Serializers.ParseNode(Namespace, nextElement, reader), null);
                            }
                        }
                    }
                    else
                    {
                        PrintError(nextElement);
                        reader.ReadToNextSibling();
                    }
                }
            }
        }

        //move to the next element
        reader.Read();
        Utilities.SkipToContent(reader);
    }


    // Utilities Method

      private void PrintError(string errorElement)
        {
            IXmlLineInfo info = reader as IXmlLineInfo;
            Log.LogIt("The attribute " + errorElement + " does not exist under " + parent + " Error Occurred at Line "
                      + info.LineNumber + " Col " + info.LinePosition, LogMessageType.Warning);
            info = null;
    }

     public static XmlReader SkipToContent(XmlReader reader)
        {
            int count = 0;
            while (reader.NodeType != XmlNodeType.Element && reader.NodeType != XmlNodeType.Attribute &&
                   reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.Text)
            {
                reader.Read(); count++;
                if (count > 2)
                {
                    //Console.WriteLine(" Stuck");
                    if (reader.EOF)
                    {
                        break;
                    }
                }
            }
            return reader;
        }

/// <summary>
/// Removes special symbols like "-","_","." from Node element name inorder to match it with the respective objects. 
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
public static string RemoveSpecialChar(string str)
        {
            str = str.Replace("-", "");
            str = str.Replace(".", "");
            str = str.Replace("_", "");
            return str;
    }

在此处输入代码
ReadIn（“input.xml”）；
公共静态GbtInfo ReadIn（字符串路径）
{
使用（XmlReader=新的XmlTextReader（路径））
{
reader.ReadToDescendant（“系统”）；
返回Serializers.ParseNode（读取器）；
}
}
公共静态解析节点（XmlReader）
{
类型t=类型（t）；
return（T）ParseNode（T，reader）；
}
公共静态对象ParseNode（类型，XmlReader）
{
var instance=Activator.CreateInstance（类型）；
IXmlSerializable xmlSerializable=实例为IXmlSerializable；
if（xmlSerializable！=null）
ReadXml（读取器）；
返回实例；
}
公共静态对象ParseNode（string name_space，string elementName，XmlReader）
{
Type t=Type.GetType（name\u space+““+elementName，false，true）；
返回ParseNode（t，reader）；
}
public void ReadXml（System.Xml.XmlReader）
{
this.reader=读取器；
字符串连接；
parent=reader.Name；
PropertyInfo PropertyInfo=null；
//如果当前节点为空，则设置标志。
bool isEmptyElement=reader.isEmptyElement；
//将属性解析出节点的代码。
if（reader.HasAttributes）
{
for（int i=0；i”+读卡器.Value）；
reader.Read（）；
实用程序。SkipToContent（阅读器）；
}
if（reader.NodeType==XmlNodeType.Element）
{
nextElement=Utilities.RemoveSpecialChar（reader.Name）；
propertyinfo=（GetType（））.GetProperty（nextElement，BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance）；
if（propertyinfo！=null）
{
if（propertyinfo.PropertyType.FullName.Equals（“System.String”））
{
reader.Read（）；//读取以获取文本
if（reader.NodeType！=XmlNodeType.Text）
抛出新的InvalidOperationException（“遇到特殊情况检查XML”）；
propertyinfo.SetValue（this，reader.Value，null）；
//测试控制台.WriteLine（读卡器.Value）；
reader.ReadToNextSibling（“dummy”）；//这将读取父端标记
reader.Read（）；
实用程序。SkipToContent（阅读器）；
}
其他的
{
System.Collections.IList list=propertyinfo.GetValue（该值为null）作为System.Collections.IList；
如果（列表！=null）
{
Add（Serializers.ParseNode（名称空间、nextElement、reader））；
}
其他的
{
propertyinfo.SetValue（this，Serializers.ParseNode（Namespace，nextElement，reader），null）；
}
}
}
其他的
{
打印错误（nextElement）；
reader.ReadToNextSibling（）；
}
}
}
}
//移动到下一个元素
reader.Read（）；
实用程序。SkipToContent（阅读器）；
}
//实用方法
私有void打印错误（字符串errorElement）
{
IXmlLineInfo=读卡器为IXmlLineInfo；
Log.LogIt（“在第行“+parent+”下不存在属性“+errorElement+”，出现错误”
+info.LineNumber+“Col”+info.LinePosition，LogMessageType.Warning）；
info=null；
}
公共静态XmlReader SkipToContent（XmlReader阅读器）
{
整数计数=0；
while（reader.NodeType！=XmlNodeType.Element&&reader.NodeType！=XmlNodeType.Attribute）&&
reader.NodeType！=XmlNodeType.EndElement&&reader.NodeType！=XmlNodeT