Exemple d'analyse de code de la sérialisation XML et de la désérialisation des objets XmlSerializer

L'espace de noms .Net correspondant à cet essai est System.Xml.Serialization ; l'exemple de code dans l'article doit faire référence à cet espace de noms.

Pourquoi devons-nous sérialiser et désérialiser ?

Lorsque le programme .Net est exécuté, les objets résident dans la mémoire ; si les objets dans la mémoire doivent être transmis à d'autres systèmes pour être utilisés ou doivent être enregistrés lors de l'arrêt afin que ; ils peuvent être réutilisés au redémarrage du programme. Nécessite une sérialisation et une désérialisation.

Portée : Cet article présente uniquement la sérialisation XML. En fait, la sérialisation peut être une sérialisation binaire ou une sérialisation dans d'autres formats.

Regardez le code de sérialisation XML le plus simple

class Program
{
    static void Main(string[] args)
    {
        int i = 10;
        //声明Xml序列化对象实例serializer
        XmlSerializer serializer = new XmlSerializer(typeof(int));
        //执行序列化并将序列化结果输出到控制台
        serializer.Serialize(Console.Out, i);
        Console.Read();
    }
}

Le code ci-dessus est correct pour int i La sérialisation est effectuée et le résultat de la sérialisation est affiché sur la console. Le résultat de sortie est le suivant

<?xml version="1.0" encoding="gb2312"?>
<int>10</int>

Le XML sérialisé ci-dessus peut être désérialisé, le code suivant

static void Main(string[] args)
{
    using (StringReader rdr = new StringReader(@"<?xml version=""1.0"" encoding=""gb2312""?>
<int>10</int>"))
    {
        //声明序列化对象实例serializer 
        XmlSerializer serializer = new XmlSerializer(typeof(int));
        //反序列化，并将反序列化结果值赋给变量i
        int i = (int)serializer.Deserialize(rdr);
        //输出反序列化结果
        Console.WriteLine("i = " + i);
        Console.Read();
    }
}

Le code ci-dessus illustre le processus de sérialisation et de désérialisation XML de la manière la plus simple. La bibliothèque de classes système .Net est Nous avons fait beaucoup. Le travail, la sérialisation et la désérialisation sont très simples. Cependant, en réalité, les exigences métier sont souvent plus complexes et il est impossible de simplement sérialiser une variable int. Lors de l'affichage, nous devons sérialiser de manière contrôlable des types complexes.

Sérialisation XML des objets personnalisés :

Il existe une série de classes de fonctionnalités dans l'espace de noms System.Xml.Serialization pour contrôler la sérialisation des types complexes. Par exemple, XmlElementAttribute, XmlAttributeAttribute, XmlArrayAttribute, XmlArrayItemAttribute, XmlRootAttribute, etc.

Regardez un petit exemple. Il existe une classe personnalisée Cat. La classe Cat a trois attributs : Couleur, Dicton et Vitesse.

namespace UseXmlSerialization
{
    class Program
    {
        static void Main(string[] args)
        {
            //声明一个猫咪对象
            var c = new Cat { Color = "White", Speed = 10, Saying = "White or black,  so long as the cat can catch mice,  it is a good cat" };

            //序列化这个对象
            XmlSerializer serializer = new XmlSerializer(typeof(Cat));

            //将对象序列化输出到控制台
            serializer.Serialize(Console.Out, c);

            Console.Read();
        }
    }

    [XmlRoot("cat")]
    public class Cat
    {
        //定义Color属性的序列化为cat节点的属性
        [XmlAttribute("color")]
        public string Color { get; set; }

        //要求不序列化Speed属性
        [XmlIgnore]
        public int Speed { get; set; }

        //设置Saying属性序列化为Xml子元素
        [XmlElement("saying")]
        public string Saying { get; set; }
    }
}

Vous pouvez utiliser XmlElement pour spécifier les attributs à sérialiser dans les nœuds enfants (par défaut, ils seront sérialisés dans les nœuds enfants ou utiliser le); Attribut XmlAttribute pour spécifier la sérialisation de l'attribut C'est un attribut du nœud XML ; il peut également être modifié par l'attribut XmlIgnore pour obliger le sérialiseur à ne pas sérialiser l'attribut modifié.

Sérialisation XML du tableau d'objets :

La sérialisation XML du tableau nécessite l'utilisation de XmlArrayAttribute et XmlArrayItemAttribute spécifie l'élément du tableau ; Nom du nœud XML, XmlArrayItemAttribute spécifie le nom du nœud XML de l'élément du tableau.

L'exemple de code suivant :

/*玉开技术博客 http://www.php.cn/ */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Serialization;

namespace UseXmlSerialization
{
    class Program
    {
        static void Main(string[] args)
        {
            //声明一个猫咪对象
            var cWhite = new Cat { Color = "White", Speed = 10, Saying = "White or black,  so long as the cat can catch mice,  it is a good cat" };
            var cBlack = new Cat { Color = "Black", Speed = 10, Saying = "White or black,  so long as the cat can catch mice,  it is a good cat" };

            CatCollection cc = new CatCollection { Cats = new Cat[] { cWhite,cBlack} };

            //序列化这个对象
            XmlSerializer serializer = new XmlSerializer(typeof(CatCollection));

            //将对象序列化输出到控制台
            serializer.Serialize(Console.Out, cc);

            Console.Read();
        }
    }

    [XmlRoot("cats")]
    public class CatCollection
    {
        [XmlArray("items"),XmlArrayItem("item")]
        public Cat[] Cats { get; set; }
    }

    [XmlRoot("cat")]
    public class Cat
    {
        //定义Color属性的序列化为cat节点的属性
        [XmlAttribute("color")]
        public string Color { get; set; }

        //要求不序列化Speed属性
        [XmlIgnore]
        public int Speed { get; set; }

        //设置Saying属性序列化为Xml子元素
        [XmlElement("saying")]
        public string Saying { get; set; }
    }
}

Le code ci-dessus affichera :

<?xml version="1.0" encoding="gb2312"?>
<cats xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://ww
w.w3.org/2001/XMLSchema">
  <items>
    <item color="White">
      <saying>White or black,  so long as the cat can catch mice,  it is a good
cat</saying>
    </item>
    <item color="Black">
      <saying>White or black,  so long as the cat can catch mice,  it is a good
cat</saying>
    </item>
  </items>
</cats>

Problème de fuite de mémoire XmlSerializer :

Merci chenlulouis, regardé attentivement msdn, il y a bien une fuite, la description de msdn est comme suit :

Assemblages générés dynamiquement

Pour améliorer les performances, l'infrastructure de sérialisation XML générera dynamiquement des assemblys pour sérialiser et désérialiser les types spécifiés. Cette infrastructure trouvera et réutilisera ces assemblages. Ce comportement ne se produit que lors de l'utilisation du constructeur suivant :

XmlSerializer(Type)
XmlSerializer.XmlSerializer(Type, String)

Si un autre constructeur est utilisé, le même programme est généré Multiple versions d'un ensemble et jamais déchargées, ce qui entraînera des fuites de mémoire et un ralentissement des performances. La solution la plus simple consiste à utiliser l’un des deux constructeurs mentionnés précédemment. Sinon, l'assembly doit être mis en cache dans une table de hachage, comme indiqué dans l'exemple suivant.

C'est-à-dire que nous utilisons XmlSerializer pour la sérialisation. Lors de l'initialisation de l'objet XmlSerializer, il est préférable d'utiliser les deux constructeurs suivants, sinon cela provoquera des fuites de mémoire.
XmlSerializer(Type)
XmlSerializer>.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!