Comment puis-je renommer les noms de classe via des attributs Xml?

Supposons que j'ai un XML-classe sérialisable appelé Chanson:

[Serializable]
class Song
{
    public string Artist;
    public string SongTitle;
}

Afin d'économiser de l'espace (et aussi semi-obscur le fichier XML), je décide de renommer les éléments xml:

[XmlRoot("g")]
class Song
{
    [XmlElement("a")]
    public string Artist;
    [XmlElement("s")]
    public string SongTitle;
}

Ceci va produire une sortie XML comme ceci:

<Song>
  <a>Britney Spears</a>
  <s>I Did It Again</s>
</Song>

Je veux renommer/reconfigurer le nom de la classe/objet. Dire, dans l'exemple ci-dessus, je souhaite renommer la classe Chanson à g. Afin que le xml résultant devrait ressembler à ceci:

<g>
  <a>Britney Spears</a>
  <s>I Did It Again</s>
</g>

Est-il possible de renommer les noms de classe via xml-attributs?

Je ne souhaite pas créer/parcourir le DOM manuellement, donc je me demandais si il pourrait être réalisé par un décorateur.

Merci d'avance!

Mise à JOUR: Oups! Cette fois, j'ai vraiment did it again!
J'ai oublié de mentionner - en fait, je suis sérialisation d'une liste d'objets de la Chanson dans le XML.

Voici le code de sérialisation:

    public static bool SaveSongs(List<Song> songs)
    {
            XmlSerializer serializer = new XmlSerializer(typeof(List<Song>));
            using (TextWriter textWriter = new StreamWriter("filename"))
            {
                serializer.Serialize(textWriter, songs);
            }
    }

Et voici le XML de sortie:

<?xml version="1.0" encoding="utf-8"?>
<ArrayOfSong>
<Song>
  <a>Britney Spears</a>
  <s>Oops! I Did It Again</s>
</Song>
<Song>
  <a>Rihanna</a>
  <s>A Girl Like Me</s>
</Song>
</ArrayOfSong>

Apparemment, le XmlRoot() attribut ne pas renommer l'objet dans un contexte de liste.

Suis-je raté quelque chose?

Je pense qu'il y a une erreur dans le fichier XML. "I did it again" n'est pas le titre exact de la chanson. Le titre exact est: "Oops!...I Did It Again". (Juste pour prévenir de futures frustrations avec les validateurs)
Pour info, [Serializable] n'est pas question pour la Sérialisation XML.
Voir ma réponse à jour basé sur vos éclaircissements.
Il y a quelques années, il pourrait donc être l'élément à mettre à jour la bonne réponse 🙂 La réponse actuellement marquée comme étant correcte est en fait incorrect de la question posée (et n'a pas pour conséquence la sortie désirée). XmlTypeAttribute et ses TypeName propriété est la façon correcte de le faire (voir ci-dessous).
Popovsky: Si vous cochez les modifications, même la toute première version de la question n'aurait pas travaillé avec XmlRoot. L'OP n'a pas été ici depuis 2 ans, donc il va continuer à induire en erreur les codeurs de partout 🙂

InformationsquelleAutor invarbrass | 2010-09-06

c#xml xml-serialization

51

La caisse de la XmlRoot attribut.

Documentation peut être trouvée ici:
http://msdn.microsoft.com/en-us/library/system.xml.serialization.xmlrootattribute(v=VS.90).aspx
```
[XmlRoot(Namespace = "www.contoso.com", 
     ElementName = "MyGroupName", 
     DataType = "string", 
     IsNullable=true)]
public class Group
```
Mise à JOUR:
Juste essayé et il fonctionne parfaitement sur VS 2008.
Ce code:
```
[XmlRoot(ElementName = "sgr")]
public class SongGroup
{
    public SongGroup()
    {
       this.Songs = new List<Song>();
    }



[XmlElement(ElementName = "sgs")]
    public List<Song> Songs { get; set; }
}

[XmlRoot(ElementName = "g")]
public class Song
{
    [XmlElement("a")]
    public string Artist { get; set; }

    [XmlElement("s")]
    public string SongTitle { get; set; }
} 
```
Sorties:
```
<?xml version="1.0" encoding="utf-8"?>
<sgr xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www
.w3.org/2001/XMLSchema">
  <sgs>
    <a>A1</a>
    <s>S1</s>
  </sgs>
  <sgs>
    <a>A2</a>
    <s>S2</s>
  </sgs>
</sgr>
```
- Eu le même problème, mais a trouvé la XmlRoot attribut ne fonctionne que sur mon nœud racine (comme je suppose qu'il devrait être basé sur les docs). Vous ne savez pas comment vous avez obtenu le code ci-dessus fonctionne correctement. L'ai eu à travailler avec [XmlType(TypeName = "nouveaunom")] sur mes classes à la place.
- La Sortie n'est pas correct, vous perdez un <g>...</p> mais ce n'est pas résoudre le problème. La solution est le post de "hi-tech de la Magie" [XmlType(TypeName="g")]
- Popovsky, et si je veux la Chanson à être un élément nommé "g" et l'Artiste et SongTitle être des attributs de cet élément. C'est à dire, <sgr><sgs><g a="A1" s="S1" /><g a="A2" s="S2"><sgs><sgr>
- utilisez [XmlAttribute("un")] et [XmlAttribute("s")] au lieu de XmlElement et vous obtiendrez des attributs au lieu d'éléments. Pour renommer la Chanson de sgs à g, il suffit de changer le ElementName dans la liste des Chansons XmlElement Attribut.
- Avis je veux <sgs> ET <g> éléments. Je ne peux pas obtenir le parent de l'élément <sgs></sgs> avec plusieurs <g> éléments à l'intérieur. Je peux voir comment le faire en changeant le nom de la classe de chant de g, mais cela va à l'encontre du but. ou je pourrais créer un modèle qui ne contient que du bien de la liste des chansons et le nom de "g", mais qui casse le reste de mon code.
- XmlArrayItem("g") est ce que je cherchais
InformationsquelleAutor Ariel Popovsky
98

Solution: Utilisez [XmlType(TypeName="g")]

XmlRoot ne fonctionne qu'avec XML racine nœuds que par la documentation (et ce que vous attendez, donné son nom comprend racine)!

Je n'ai pu obtenir aucune des autres réponses à travailler de sorte gardé creuser...

Au lieu de cela, j'ai trouvé que le XmlTypeAttribute (c'est à dire [XmlType]) et de ses TypeName bien faire un travail similaire pour non-root classes/objets.

par exemple
```
[XmlType(TypeName="g")]
class Song
{
    public string Artist;
    public string SongTitle;
}
```
En supposant que vous appliquer pour les autres classes, par exemple:
```
[XmlType(TypeName="a")]
class Artist
{
    .....
}

[XmlType(TypeName="s")]
class SongTitle
{
    .....
}
```
Ce sera la sortie de la suite de exactement comme requis dans la question:
```
<g>
  <a>Britney Spears</a>
  <s>I Did It Again</s>
</g>
```
J'ai utilisé dans plusieurs projets de production et n'a trouvé aucun problème avec elle.
- - il encore sorties <?xml version="1.0" encoding="utf-16"?>
- C'est jusqu'à la sortie de l'encodage, pas la XmlType décrit ici. Veuillez poser une nouvelle question si vous en avez un 🙂
- C'est exactement ce que je cherchais, merci!
- Cette réponse fonctionne beaucoup mieux que la réponse choisie.
- Malheureusement, l'OP n'a pas été en ligne pendant de nombreuses années, de sorte qu'il reste coincé sur une réponse incorrecte 🙂
- Cette solution ne fonctionne pas pour moi pour le nœud racine. La accepté de répondre à des œuvres.
- l'on a accepté la réponse est correcte pour la question d'origine, qui plus tard a été édité. Il ne me laisse pas supprimer mon downvote. Désolé.
InformationsquelleAutor Gone Coding

Si c'est l'élément racine du document, vous pouvez utiliser [XmlRoot("g")].

Voici ma mise à jour en fonction de vos éclaircissements. Le degré de contrôle que vous demandez n'est pas possible sans un emballage de classe. Cet exemple utilise un SongGroup classe pour envelopper la liste, de sorte que vous pouvez donner d'autres noms pour les éléments à l'intérieur.

using System;
using System.Collections.Generic;
using System.IO;
using System.Xml.Serialization;
public class SongGroup
{
public SongGroup()
{
this.Songs = new List<Song>();
}
[XmlArrayItem("g", typeof(Song))]
public List<Song> Songs { get; set; }
}
public class Song 
{ 
public Song()
{
}
[XmlElement("a")] 
public string Artist { get; set; }
[XmlElement("s")]
public string SongTitle { get; set; }
} 
internal class Test
{
private static void Main()
{
XmlSerializer serializer = new XmlSerializer(typeof(SongGroup));
SongGroup group = new SongGroup();
group.Songs.Add(new Song() { Artist = "A1", SongTitle = "S1" });
group.Songs.Add(new Song() { Artist = "A2", SongTitle = "S2" });
using (Stream stream = new MemoryStream())
using (StreamWriter writer = new StreamWriter(stream))
{
serializer.Serialize(writer, group);
stream.Seek(0, SeekOrigin.Begin);
using (StreamReader reader = new StreamReader(stream))
{
Console.WriteLine(reader.ReadToEnd());
}
}
}
}

Cela a aussi pour effet de générer une plus intérieure de l'élément représentant la liste elle-même. Sur mon système, la sortie ressemble à ceci:

<?xml version="1.0" encoding="utf-8"?>
<SongGroup xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<Songs>
<g>
<a>A1</a>
<s>S1</s>
</g>
<g>
<a>A2</a>
<s>S2</s>
</g>
</Songs>
</SongGroup>

Je sais que c'est une très vieille question/réponse, mais la sortie spécifique qu'ils voulaient est disponible avec XmlType(TypeName="g")]. Vous n'avez pas besoin d'un emballage classe et peut attribuer les classes elles-mêmes. Des acclamations.

InformationsquelleAutor bobbymcr

0
```
[XmlRoot("g")]
class Song
{
}
```
Devrait faire l'affaire
- La chanson n'est pas l'élément Racine, de sorte que cela ne fonctionnera pas. XmlRoot s'applique uniquement au nœud racine. Désolé.
InformationsquelleAutor Raj
0

Utilisation XmlElementAttribute: http://msdn.microsoft.com/en-us/library/system.xml.serialization.xmlrootattribute.aspx
```
[Serializable]
[XmlRoot(ElementName="g")]
class Song
{
public string Artist;
public string SongTitle;
}
```
devrait fonctionner.
- La chanson n'est pas l'élément Racine, de sorte que cela ne fonctionnera pas. XmlRoot s'applique uniquement au nœud racine. Désolé.
InformationsquelleAutor Andreas Paulsson

Vous devez vous connecter pour publier un commentaire.

Solution: Utilisez [XmlType(TypeName="g")]