C＃解析XML Attriubte与名称与名字b记录它

Question

我有一个XML DOM

<xml> 
<ElementA/> 
<xml> 

现在我的XML改变

<xml> 
<ElementB/> 
<xml> 

ElementB的值的A是simular但我有ElementA的一些文件，并且必须将它们迁移到ElementB。

我与XmlSerializer的

工作是否可以读取两个节点的一个参数，并将其写入到一个属性名称，比如

[XmlElement("ElementB")] 
[XmlElement("ElementA")] // Writing this version only somehow 
    public float Rating 
    { get; set; } 

Answer 1

我已经使用Linq to XML（System.Xml.Linq）在过去做了这种模式迁移工作，并取得了巨大成功。您的代码看起来是这样的：

XDocument doc = XDocument.Load("<path to input xml document>"); 
foreach (var element in doc.Descendants("AttributeA")) 
{ 
    element.Name = "AttributeB"; 
} 
doc.Save("<path to output xml document>"); 

基本上，你刚才读在整个文档中成和的XDocument，发现您是通过LINQ的寻找节点，操纵他们的价值观，并写了改变的XDocument回给光盘。如果你仍然想使用Xml序列化，你可以再次从光盘上读取文档，并继续像以前一样处理。

Answer 2

你可以做你想做的与XML属性覆盖。实质上， 您可以在运行时将XML序列化属性应用于序列化程序。

See the MSDN Article

下面是使用XML一些示例代码属性重写与XML序列化。

public class DTO 
{ 
    [XmlIgnore] 
    public string additionalInformation; 

    [XmlElement(Order=1)] 
    public DateTime stamp; 

    [XmlElement(Order=2)] 
    public string name; 

    [XmlElement(Order=3)] 
    public double value; 

    [XmlElement(Order=4)] 
    public int index; 
} 


public class OverridesDemo 
{ 
    public void Run() 
    { 
     DTO dto = new DTO { 
      additionalInformation = "This information will be serialized separately", 
      stamp = DateTime.UtcNow, 
      name = "Marley", 
      value = 72.34, 
      index = 7 
     }; 

     // this will allow us to omit the xmlns:xsi namespace 
     var ns = new XmlSerializerNamespaces(); 
     ns.Add("", ""); 

     XmlSerializer s1 = new XmlSerializer(typeof(DTO)); 

     var builder = new System.Text.StringBuilder(); 
     var settings = new XmlWriterSettings { OmitXmlDeclaration = true, Indent= true }; 

     Console.WriteLine("\nSerialize using the in-line (compile-time) attributes: "); 
     using (XmlWriter writer = XmlWriter.Create(builder, settings)) 
     { 
      s1.Serialize(writer, dto, ns); 
     } 
     Console.WriteLine("{0}",builder.ToString()); 
     Console.WriteLine("\n"); 


     // use a default namespace 
     ns = new XmlSerializerNamespaces(); 
     string myns = "urn:www.example.org"; 
     ns.Add("", myns); 

     XmlAttributeOverrides overrides = new XmlAttributeOverrides(); 

     XmlAttributes attrs = new XmlAttributes(); 
     // override the (implicit) XmlRoot attribute 
     XmlRootAttribute attr1 = new XmlRootAttribute 
      { 
       Namespace = myns, 
       ElementName = "DTO-Annotations", 
      }; 
     attrs.XmlRoot = attr1; 

     overrides.Add(typeof(DTO), attrs); 
     // "un-ignore" the first property 
     // define an XmlElement attribute, for a type of "String", with no namespace 
     var a2 = new XmlElementAttribute(typeof(String)) { ElementName="note", Namespace = myns }; 

     // add that XmlElement attribute to the 2nd bunch of attributes 
     attrs = new XmlAttributes(); 
     attrs.XmlElements.Add(a2); 
     attrs.XmlIgnore = false; 

     // add that bunch of attributes to the container for the type, and 
     // specifically apply that bunch to the "Label" property on the type. 
     overrides.Add(typeof(DTO), "additionalInformation", attrs); 

     // ignore the other properties 

     // add the XmlIgnore attribute to the 2nd bunch of attributes 
     attrs = new XmlAttributes(); 
     attrs.XmlIgnore = true; 

     // add that bunch of attributes to the container for the type, and 
     // specifically apply that bunch to the "Label" property on the type. 
     overrides.Add(typeof(DTO), "stamp", attrs); 
     overrides.Add(typeof(DTO), "name", attrs); 
     overrides.Add(typeof(DTO), "value", attrs); 
     overrides.Add(typeof(DTO), "index", attrs); 

     XmlSerializer s2 = new XmlSerializer(typeof(DTO), overrides); 

     Console.WriteLine("\nSerialize using the override attributes: "); 
     builder.Length = 0; 
     using (XmlWriter writer = XmlWriter.Create(builder, settings)) 
     { 
      s2.Serialize(writer, dto, ns); 
     } 
     Console.WriteLine("{0}",builder.ToString()); 
     Console.WriteLine("\n"); 
    } 

您可以使用覆盖进行序列化或反序列化。