C# 用C语言序列化和反序列化带有注释部分的XML#

我想知道如何将注释部分保存在XML中（序列化之后）。 有什么办法吗

这是我的问题， 我有很多节点的XML文件。我的.NET应用程序将加载XML文件并序列化到C#类中。然后将更改类中的一些节点（按BL），并再次反序列化和保存文件。 保存后，我在某些节点上保留的注释将消失

有没有办法避免使用C#重置XML注释

---

提前感谢

假设是这样的xml

<?xml version="1.0" encoding="utf-8"?>
<Test>
    <!--Foo Description!-->
    <Foo>FooText</Foo>
    <!--Bar Description!-->
    <Bar>BarText</Bar>
</Test>

var xml = GenericSerializator<Test>.LoadObjectFromFile("test.xml");

xml.Foo += "1";
xml.FooCommnet += "2";
xml.Bar += "3";
xml.BarCommnet += "4";

GenericSerializator<Test>.SaveObjectToFile(xml, "test2.xml");

<?xml version="1.0" encoding="utf-16"?>
<Test>
  <!--Foo Description!2-->
  <Foo>FooText1</Foo>
  <!--Bar Description!4-->
  <Bar>BarText3</Bar>
</Test>

足迹
巴尔特克斯
var xml=GenericSerializator.LoadObjectFromFile（“test.xml”）；
xml.Foo+=“1”；
xml.foocomnet+=“2”；
xml.Bar+=“3”；
xml.BarCommnet+=“4”；
SaveObjectToFile（xml，“test2.xml”）；
脚踏板1
BarText3

我们可以使用以下代码执行此操作：

    internal static class GenericSerializator<T> where T : class
    {
        public static T LoadObjectFromFile(string fileName)
        {
            using (var file = new FileStream(fileName, FileMode.Open, FileAccess.Read))
            {
                var xmlSerializer = new XmlSerializer(typeof(T));
                return (T)xmlSerializer.Deserialize(file);
            }
        }

        public static void SaveObjectToFile(object value, string fileName)
        {
            var xmlSerializer = new XmlSerializer(typeof(T));
            using (var fileStream = new FileStream(fileName, FileMode.Create, FileAccess.Write))
            {
                fileStream.Seek(0, SeekOrigin.End);
                using (var streamWriter = new StreamWriter(fileStream, Encoding.Unicode))
                {
                    xmlSerializer.Serialize(streamWriter, value);
                }
            }
        }
    }

    public class Test : XmlSerializableWithComments
    {
        [XmlIgnore, Description]
        public string FooCommnet { get; set; }

        public string Foo { get; set; }

        [XmlIgnore, Description]
        public string BarCommnet { get; set; }

        public string Bar { get; set; }
    }

    public class XmlSerializableWithComments : IXmlSerializable
    {
        private PropertyInfo[] Properties { get; set; }

        public XmlSerializableWithComments()
        {
            Properties = GetType().GetProperties();

        }
        public void WriteXml(XmlWriter writer)
        {
            foreach (var propertyInfo in Properties)
            {
                var value = propertyInfo.GetValue(this, null).ToString();
                if (propertyInfo.IsDefined(typeof(DescriptionAttribute), false))
                {
                    writer.WriteComment(value);
                }
                else
                {
                    writer.WriteElementString(propertyInfo.Name, value);
                }

            }
        }
        public XmlSchema GetSchema()
        {
            throw new NotImplementedException();
        }

        public void ReadXml(XmlReader reader)
        {
            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.EndElement)
                {
                    reader.Read();
                }

                string comment = null;
                if (reader.NodeType == XmlNodeType.Comment)
                {
                    comment = reader.Value;
                }

                reader.Read();

                if (reader.NodeType == XmlNodeType.Element)
                {
                    var propertyName = reader.LocalName;

                    PropertyInfo temp;
                    if ((temp = Properties.FirstOrDefault(i => i.Name == propertyName)) != null)
                    {
                        reader.Read();
                        temp.SetValue(this, reader.Value);
                        if (!string.IsNullOrEmpty(comment))
                        {
                            if ((temp = Properties.FirstOrDefault(i => i.Name == propertyName + "Commnet")) != null)
                            {
                                temp.SetValue(this, comment);
                            }
                            comment = null;
                        }
                    }
                }
            }
        }
    }
}

内部静态类GenericSerializator，其中T:class
{
公共静态T LoadObjectFromFile（字符串文件名）
{
使用（var file=newfilestream（文件名，FileMode.Open，FileAccess.Read））
{
var xmlSerializer=新的xmlSerializer（typeof（T））；
返回（T）xmlSerializer.Deserialize（文件）；
}
}
公共静态void SaveObjectToFile（对象值、字符串文件名）
{
var xmlSerializer=新的xmlSerializer（typeof（T））；
使用（var fileStream=newfilestream（文件名，FileMode.Create，FileAccess.Write））
{
Seek（0，SeekOrigin.End）；
使用（var streamWriter=newstreamwriter（fileStream，Encoding.Unicode））
{
序列化（streamWriter，值）；
}
}
}
}
公共类测试：XmlSerializableWithComments
{
[XmlIgnore，Description]
公共字符串foocomnet{get；set；}
公共字符串Foo{get；set；}
[XmlIgnore，Description]
公共字符串BarCommnet{get；set；}
公共字符串条{get；set；}
}
带有注释的公共类XmlSerializable:IXmlSerializable
{
私有属性info[]属性{get；set；}
公共XmlSerializableWithComments（）
{
Properties=GetType（）.GetProperties（）；
}
public void WriteXml（XmlWriter）
{
foreach（属性中的var propertyInfo）
{
var value=propertyInfo.GetValue（this，null）.ToString（）；
if（定义了propertyInfo.IsDefined（typeof（DescriptionAttribute），false））
{
writer.WriteComment（值）；
}
其他的
{
writer.WriteElementString（propertyInfo.Name，value）；
}
}
}
公共XmlSchema GetSchema（）
{
抛出新的NotImplementedException（）；
}
公共void ReadXml（XmlReader）
{
while（reader.Read（））
{
if（reader.NodeType==XmlNodeType.EndElement）
{
reader.Read（）；
}
字符串注释=null；
if（reader.NodeType==XmlNodeType.Comment）
{
评论=读者价值；
}
reader.Read（）；
if（reader.NodeType==XmlNodeType.Element）
{
var propertyName=reader.LocalName；
属性信息温度；
if（（temp=Properties.FirstOrDefault（i=>i.Name==propertyName））！=null）
{
reader.Read（）；
温度设置值（该值为读卡器值）；
如果（！string.IsNullOrEmpty（注释））
{
if（（temp=Properties.FirstOrDefault（i=>i.Name==propertyName+“Commnet”））！=null）
{
温度设置值（此，注释）；
}
注释=null；
}
}
}
}
}
}
}

第二次序列化，您是否按照第一次序列化的方式进行序列化？另外，提供一些代码。如果您能提供以下检查，那将非常棒：