XmlSerializer: tuần tự hóa thuộc tính lớp dưới dạng thuộc tính của một subelement tùy chỉnh

Question

Tôi đang sử dụng XmlSerializer. Lớp học của tôi:

[Serializable] 
[XmlRoot(ElementName="MyClass")] 
public class MyClass 
{ 
    public string Value; 
} 

Tôi muốn serialize nó để Value kết thúc như là một thuộc tính của một subelement tên (ví dụ) "Văn bản".

kết quả mong muốn:

<MyClass> 
    <Text Value="3"/> 
</MyClass> 

Nhưng KHÔNG (đó sẽ là ảnh hưởng của giá trị gia tăng đánh dấu như một XmlAttribute)

<MyClass Value="3"> 
</MyClass> 

Và KHÔNG (mà sẽ là hiệu quả đánh dấu Giá trị là XmlElement):

<MyClass> 
    <Value>3</Value> 
</MyClass> 

Làm cách nào để đạt được điều này?

Tôi biết rằng tôi có thể thay đổi loại Value từ chuỗi thành một lớp tùy chỉnh tuần tự khác.

Thật không may, tôi có nhiều thuộc tính như vậy, vì vậy tôi cần tạo hàng tá lớp học nhỏ.

Có giải pháp nào nhanh hơn không?

---

EDIT:

Đáp lại ý kiến ​​của bạn:

• Không, không phải mọi tài sản phải được đăng một subelement tên "Text". Tên của danh sách con là duy nhất và không rõ ràng.

• Mẫu đầu ra XML:

  <visibility> 
      <site visible="yes"/> 
      <comparator visible="no"/> 
      <expiration days="7"/> 
      <comment>blahblahblah</comment> 
  <visibility> 
  

• mẫu lớp:

!

[XmlRoot(ElementName="Visibility")] 
public class Visibility 
{ 
    [XPath("/site@visible")] // if only this was possible! 
    public string OnSite 
    { 
     get { return SiteVisible ? "yes" : "no"; } 
    } 

    [XPath("/comparator@visible")] // as above... 
    public string InComparator 
    { 
     get { return ComparatorVisible ? "yes" : "no"; } 
    } 

    [XmlIgnore] 
    public bool SiteVisible; 
    [XmlIgnore] 
    public bool ComparatorVisible; 

    [XPath("/expiration@days")] // as above... 
    public int ExpiresAfterDays; 

    [XmlElement("comment")] // this is easy 
    public string Comment; 
} 

Answer 1

Không thay đổi loại Value Tôi nghĩ điều đó là không thể. Bạn có thể thêm các thuộc tính XmlElement(ElementName="Text") trên Value nhưng bạn sẽ có được một kết quả tương tự như sau:

<MyClass> 
    <Text>3</Text> 
</MyClass> 

được sửa đổi: Một giải pháp khác có thể liên quan đến việc chuyển đổi XSLT: bạn có thể tạo xml sử dụng Net serialization và sau khi áp dụng một xml chuyển đổi.

XslTransform myXslTransform = new XslTransform(); 
myXslTransform.Load(xsltDoc); 
myXslTransform.Transform(sourceDoc, resultDoc); 

Các trasformation của ví dụ của tôi nên một cái gì đó như thế này:

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
    <xsl:template match="/"> 
    <root> 
     <xsl:apply-templates/> 
    </root> 
    </xsl:template> 
    <xsl:template match="MyClass"> 
     <MyClass> 
      <Text> 
       <xsl:attribute name="Value"> 
        <xsl:value-of select="Text"/> 
       </xsl:attribute> 
      </Text> 
     </MyClass> 
    </xsl:template> 
</xsl:stylesheet> 

Answer 2

Đối với loại này linh hoạt, bạn thực sự nên suy nghĩ về việc thực hiện IXmlSerializable vì điều này mang đến cho bạn kiểm soát nhiều hơn nữa:

[XmlRoot("visibility")] 
public class Visibility : IXmlSerializable 
{ 
    public string Site; 
    public string Comparator; 
    public int Expiration; 
    public string Comment; 

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

    public void ReadXml(XmlReader reader) 
    { 
     // implement me if you want to deserialize too. 
     throw new NotImplementedException(); 
    } 

    public void WriteXml(XmlWriter writer) 
    { 
     WriteProperty(writer, "site", "visible", Site); 
     WriteProperty(writer, "comparator ", "visible", Comparator); 
     WriteProperty(writer, "expiration ", "days", Expiration); 

     if (!string.IsNullOrEmpty(Comment)) 
     { 
      writer.WriteElementString("comment", Comment); 
     } 
    } 

    private void WriteProperty<T>(XmlWriter writer, string elementName, string attibuteName, T value) 
    { 
     if (value != null) 
     { 
      writer.WriteStartElement(elementName); 
      writer.WriteAttributeString(attibuteName, value.ToString()); 
      writer.WriteEndElement(); 
     } 
    } 
} 

Rõ ràng, có một chút công việc thủ công ở đây, nhưng nó cho phép bạn giữ tất cả các mã tuần tự ở một nơi, thay vì có sự gia tăng của cla nhỏ hơn sses.

Ví dụ trên chỉ thực hiện tuần tự hóa - bạn cần viết một triển khai deserialize tương đương nếu bạn cần deserialize từ xml đến loại của bạn.

Answer 3

Cảm ơn tất cả các câu trả lời. Thật đáng tiếc là thư viện .NET XmlSerialization không cho phép điều đó (tôi nghĩ nó nên!). Tôi đang tìm một giải pháp chung chung nhất có thể.

Điều tốt nhất tôi có thể đưa ra (tốt nhất xem xét các tiêu chí về tính tổng thể tối đa, trong khi thực hiện nhanh chóng một cách hợp lý) là cho phép sắp xếp từng lớp theo cách của nó, sau đó chỉ chuyển đổi đầu ra, di chuyển các phần tử nhất định vào các vị trí lồng nhau.

Something như thế:

/// <remarks> 
    /// (angle brackets replaced with round ones to avoid confusing the XML-based documentation comments format) 
    /// 
    /// Let input XML be: 
    /// 
    ///  (root) 
    ///   (days)3(/days) 
    ///  (/root) 
    ///  
    /// Calling Reposition on this input with mappings argument being: 
    ///  (key) "days" 
    ///  (value) { "time", "days" } 
    ///  
    /// Returns: 
    /// (root) 
    ///  (time days="3" /) 
    /// (/root) 
    /// </remarks>   
    static XElement Reposition(XElement input, KeyValuePair<string, string[]>[] mappings) 
    { 
     var result = new XElement(input); 
     foreach (var mapping in mappings) 
     { 
      var element = result.Element(mapping.Key); 
      if (element == null) 
      { 
       continue; 
      } 
      var value = element.Value; 
      element.Remove(); 

      var insertAt = result; 
      foreach (var breadcrumb in mapping.Value) 
      { 
       if (breadcrumb == mapping.Value.Last()) 
       { 
        insertAt.Add(new XAttribute(breadcrumb, value)); 
       } 
       else 
       { 
        insertAt.Add(new XElement(breadcrumb)); 
        insertAt = insertAt.Element(breadcrumb); 
       } 
      } 
     } 
     return result; 
    } 

Tôi nghĩ rằng tôi sẽ kết hợp nó với một thuộc tính tùy chỉnh (loại tương tự như thuộc tính XPath mà tôi mong sẽ tồn tại: xem mã mẫu trong câu hỏi của tôi), và quấn lại chức năng này trong một lớp serializer của riêng tôi.

Mọi nhận xét/thông tin chi tiết về cách tiếp cận này?

Tôi có thể nghĩ về một nhược điểm hiệu suất tiềm năng (viết lại/reparsing XML sau mỗi serialization), nhưng các phần kết quả của XML không được dự kiến ​​sẽ có kích thước lớn, vì vậy điều này có lẽ không đáng kể.

Câu hỏi về deserialization không làm phiền tôi vào thời điểm này (deserialization đã được thực hiện và được thực hiện khá "thủ công", bởi XPath và một số phương pháp tiện ích).