Sérialization et désérialization XML et SOAP (un XML manager complet, à convertir en DLL ou COM+)

Avril 2018


Description


Bonjour.
Dans le cadre de mon travail, j'étais souvent amené à sérialiser ou désérialisation des objets ou des flux XML pour des fin de traitement, ou de communication.
Le concept de la sérialisation est de rendre un objet persistant. L''objet peut être alors impliqué dans des traitements ou envoyé à travers un réseau tout en gardant le même format par une simple conversion objet/xml ou xml/objet.
Ce processus peut également être appliqué à des flux SOAP. Du coup, on a la possibilité d''embarquer directement un objet dans un flux SOAP, et l''envoyer se balader sur une MQ Series par exemple ;-) (humour technique, c''est ce qu''il faut éviter avec les filles)
Une conversion binaire est également possible via le Framework 1.1 de Microsoft.
Comme vous pouvez le constater, cette classe comporte des méthodes statiques, facilement embarquables et exploitables dans vos projet .NET.
Nous verrons dans un prochain article comment définir un COM+ à partir de cette classe, le déployer, l''exporter, l''exploiter.
Enjoy ;-)


Les procédures sont commentées, un exemple de génération de namespace est indiqué au début, les namespaces sont obligatoires pour les flux indentés de préfixe...

Code commenté


using System;
using System.IO;
using System.Text;
using System.Xml;
using System.Xml.Serialization;
using System.Runtime.Serialization.Formatters.Soap;

namespace XMLMAnager
{
    /// <summary>
    /// Description résumée de XMLManager.
    /// </summary>
    public class XMLManagerClass
    {
        public XMLManagerClass()
        {
            //
            // TODO : ajoutez ici la logique du constructeur
            //
        }
        
        #region SOAP && XML Serializer
        
        #region declaration d'un namespace
        //XmlSerializerNamespaces myNamespaces = new XmlSerializerNamespaces();
        //myNamespaces.Add("prefixe1","url_prefixe1");
        //myNamespaces.Add("prefixe1","url_prefixe1");
        #endregion


        public static String SerializeSOAPString(object request, XmlSerializerNamespaces myNamespaces)
        {
            XmlSerializer serializerXML = new XmlSerializer(request.GetType());
            MemoryStream memStream = new MemoryStream();
            serializerXML.Serialize(memStream, request,myNamespaces);
            return ConvertStreamToString(memStream);
        }


        /// <summary>
        /// Derialiser et retourne un fichier
        /// </summary>        
        public static bool SerializeSOAPFile(object objet, string pathFile)
        {
            if (objet == null)
                return false;

            FileStream stream = new FileStream(pathFile, FileMode.Create);
            SoapFormatter objetSoap = new SoapFormatter();

            objetSoap.Serialize(stream, objet);
            
            stream.Close();
            return true;
        }

        /// <summary>
        /// Déserialise à partir d'un string et return objet
        /// </summary>
        /// <returns></returns>
        public static object DeserializeSOAPString(string sSoap)
        {
            SoapFormatter objetSoap = new SoapFormatter();
    
            object resultat = null;
            resultat = objetSoap.Deserialize(ConvertStringToStream(sSoap));
            return resultat;
        }

        /// <summary>
        /// Déserialise à partir d'un fichier et retourne un objet
        /// </summary>
        /// <returns></returns>
        public static object DeserializeSOAPFile(string fichier)
        {
            if (!File.Exists(fichier))
                return null;

            SoapFormatter objetSoap = new SoapFormatter();
            FileStream stream = new FileStream(fichier, FileMode.Open);

            object resultat = null;
            resultat = objetSoap.Deserialize(stream);
            stream.Close();
            return resultat;
        }

    
        #region XML
        public static string SerializeXMLString(object objet, Type type, XmlSerializerNamespaces myNamespaces)
        {
            XmlSerializer x = new XmlSerializer(type);
            StringWriter writer = new StringWriter();
            x.Serialize(writer,objet,myNamespaces);
            return writer.GetStringBuilder().ToString();
        }

        public static bool SerializeXMLFile(object objet, string pathFile, Type type)
        {            
            XmlSerializer x = new XmlSerializer(type);
            TextWriter writer = new StreamWriter(pathFile);
            x.Serialize(writer,objet);
            writer.Close();
            return true;
        }

        public static object DeserializeXMLFile(string pathFile, Type type)
        {
            XmlSerializer x = new XmlSerializer(type);
            FileStream FS = new FileStream(pathFile,FileMode.Open);

            XmlReader reader = new XmlTextReader(FS);
            return x.Deserialize(reader);
        }
        
        public static object DeserializeXMLString(string sr, Type type)
        {
            XmlSerializer x = new XmlSerializer(type);
            StringReader strR = new StringReader(sr);
            return x.Deserialize(strR);
        }

        public static object DeserializeXMLString(string sr, Type type,XmlRootAttribute root)
        {
            XmlSerializer x = new XmlSerializer(type,root);
            StringReader strR = new StringReader(sr);
            return x.Deserialize(strR);
        }

        #endregion

        #endregion

        #region Conversion Stream && String

        public static string ConvertStreamToString(Stream leStream)
        {
            if(leStream.Position>0 && leStream.CanSeek) leStream.Position=0;
            string leString="";
            using (StreamReader sr = new StreamReader(leStream) )
            {
                leString = sr.ReadToEnd();
                sr.Close();
            }
            return leString;
        }

        public static MemoryStream ConvertStringToStream(string stringval)
        {
            byte[] stringbytes = ASCIIEncoding.ASCII.GetBytes(stringval);
            MemoryStream st = new MemoryStream(stringbytes);
            return st;
        }

        #endregion
    }
}

A voir également

Publié par junkie_333.
Ce document intitulé «  Sérialization et désérialization XML et SOAP (un XML manager complet, à convertir en DLL ou COM+)  » issu de CodeS-SourceS (https://codes-sources.commentcamarche.net/) est mis à disposition sous les termes de la licence Creative Commons. Vous pouvez copier, modifier des copies de cette page, dans les conditions fixées par la licence, tant que cette note apparaît clairement.
Ajouter un commentaire

Commentaires

Commenter la réponse de Utilisateur anonyme
"Data Transfer Object" Pattern, Data Access & Web Service
Nouveautés syntaxiques de C# 3.0