XmlSerializer: sérialisation d'une propriété de classe comme un attribut d'un sous-élément

Sans changer le type de Value je pense qu'il n'est pas possible. Vous pouvez ajouter l'attribut XmlElement(ElementName="Text") sur Value mais vous permettra d'obtenir un résultat similaire à ceci:

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

Édité:
Une autre solution peut impliquer de transformation XSLT: vous pouvez générer le xml à l'aide .Net de la sérialisation et après appliquer une transformation xml.

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

La trasformation de mon exemple doit être quelque chose comme ceci:

<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>

OriginalL'auteur Max Zerbini

Merci pour toutes les réponses. Il est dommage que .NET XmlSerialization bibliothèque ne permettent pas que (je pense que ça devrait le faire!). Je suis à la recherche d'une solution aussi générique que possible.

Le meilleur que je pouvais venir avec (meilleur tenu compte du critère de maximum de genericity, tout en étant assez rapide à mettre en œuvre) est de laisser les XmlSerializer sérialiser ma classe la façon dont elle aime, puis il suffit de convertir la sortie, la délocalisation de certains éléments imbriqués endroits.

Quelque chose comme ça:

    ///<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;
    }

Je pense que je serais de le combiner avec un attribut personnalisé (sorte de semblable à la XPath attribut que j'ai voulu existerait: voir l'exemple de code dans ma question), et envelopper cette fonctionnalité dans un sérialiseur classe de mon propre.

Tout commentaires /points de vue sur cette approche?

Je peux penser à un potentiel de rendement inconvénient (réécriture/ré-XML après chaque sérialisation), mais le résultat de morceaux de XML ne sont pas censés être de grande taille, donc c'est probablement négligeable.

La question de la désérialisation ne me dérange pas à ce point (la désérialisation a déjà été mis en œuvre et est tout à fait "à la main", par XPath et quelques méthodes utiles).

OriginalL'auteur Konrad Morawski