Convertir une chaîne XML en objet

Je reçois des chaînes XML sur une socket et j'aimerais les convertir en objets C #.

Les messages sont de la forme:

<msg>
   <id>1</id>
   <action>stop</action>
</msg>

Je suis nouveau sur .Net et je ne suis pas sûr de la meilleure pratique pour effectuer cela. J'ai déjà utilisé JAXB pour Java, et je ne savais pas s'il y avait quelque chose de similaire ou si cela serait géré d'une manière différente.

Vous devez utiliser l' xsd.exeoutil qui est installé avec le SDK Windows dans un répertoire similaire à:

C:\Program Files\Microsoft SDKs\Windows\v6.0A\bin

Et sur les ordinateurs 64 bits:

C:\Program Files (x86)\Microsoft SDKs\Windows\v6.0A\bin

Et sur les ordinateurs Windows 10:

C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\bin

Lors de la première exécution, vous utilisez xsd.exeet vous convertissez votre exemple de XML en un fichier XSD (fichier de schéma XML):

xsd yourfile.xml

Cela vous donne yourfile.xsd, que dans un deuxième temps, vous pouvez convertir à nouveau en utilisant xsd.exeune classe C #:

xsd yourfile.xsd /c

Cela devrait vous donner un fichier yourfile.csqui contiendra une classe C # que vous pouvez utiliser pour désérialiser le fichier XML que vous obtenez - quelque chose comme:

XmlSerializer serializer = new XmlSerializer(typeof(msg));
msg resultingMessage = (msg)serializer.Deserialize(new XmlTextReader("yourfile.xml"));

Cela devrait plutôt bien fonctionner dans la plupart des cas.

Mise à jour: le sérialiseur XML prendra n'importe quel flux comme entrée - un fichier ou un flux mémoire conviendra:

XmlSerializer serializer = new XmlSerializer(typeof(msg));
MemoryStream memStream = new MemoryStream(Encoding.UTF8.GetBytes(inputString));
msg resultingMessage = (msg)serializer.Deserialize(memStream);

ou utilisez un StringReader:

XmlSerializer serializer = new XmlSerializer(typeof(msg));
StringReader rdr = new StringReader(inputString);
msg resultingMessage = (msg)serializer.Deserialize(rdr);

Vous avez deux possibilités.

Méthode 1. Outil XSD

1. Ouvrez l' invite de commande du développeur
   Vous pouvez le trouver dans Start Menu > Programs > Microsoft Visual Studio 2012 > Visual Studio Tools Ou si vous avez Windows 8, vous pouvez simplement commencer à taper l' invite de commande du développeur dans l' écran de démarrage
2. Changez l'emplacement de votre répertoire de fichiers XML en tapant cd /D "C:\path\to\xml"
3. Créez un fichier XSD à partir de votre fichier xml en tapantxsd file.xml
4. Créer des classes C # en tapantxsd /c file.xsd

Et c'est tout! Vous avez généré des classes C # à partir d'un fichier xml dansC:\path\to\xml\file.cs

Méthode 2 - Collage spécial

1. Copiez le contenu de votre fichier XML dans le presse-papiers
2. Ajoutez à votre solution un nouveau fichier de classe vide ( Shift+ Alt+ C)
3. Ouvrez ce fichier et dans le menu, cliquez sur Edit > Paste special > Paste XML As Classes
   

Et c'est tout!

Usage

L'utilisation est très simple avec cette classe d'assistance:

using System;
using System.IO;
using System.Web.Script.Serialization; // Add reference: System.Web.Extensions
using System.Xml;
using System.Xml.Serialization;

namespace Helpers
{
    internal static class ParseHelpers
    {
        private static JavaScriptSerializer json;
        private static JavaScriptSerializer JSON { get { return json ?? (json = new JavaScriptSerializer()); } }

        public static Stream ToStream(this string @this)
        {
            var stream = new MemoryStream();
            var writer = new StreamWriter(stream);
            writer.Write(@this);
            writer.Flush();
            stream.Position = 0;
            return stream;
        }


        public static T ParseXML<T>(this string @this) where T : class
        {
            var reader = XmlReader.Create(@this.Trim().ToStream(), new XmlReaderSettings() { ConformanceLevel = ConformanceLevel.Document });
            return new XmlSerializer(typeof(T)).Deserialize(reader) as T;
        }

        public static T ParseJSON<T>(this string @this) where T : class
        {
            return JSON.Deserialize<T>(@this.Trim());
        }
    }
}

Tout ce que vous avez à faire maintenant, c'est:

    public class JSONRoot
    {
        public catalog catalog { get; set; }
    }
    // ...

    string xml = File.ReadAllText(@"D:\file.xml");
    var catalog1 = xml.ParseXML<catalog>();

    string json = File.ReadAllText(@"D:\file.json");
    var catalog2 = json.ParseJSON<JSONRoot>();

Essayez cette méthode pour convertir du XML en objet. Il est fait exactement pour ce que vous faites:

protected T FromXml<T>(String xml)
{
    T returnedXmlClass = default(T);

    try
    {
        using (TextReader reader = new StringReader(xml))
        {
            try
            {
                returnedXmlClass = 
                    (T)new XmlSerializer(typeof(T)).Deserialize(reader);
            }
            catch (InvalidOperationException)
            {
                // String passed is not XML, simply return defaultXmlClass
            }
        }
    }
    catch (Exception ex)
    {
    }

    return returnedXmlClass ;        
}

Appelez-le en utilisant ce code:

YourStrongTypedEntity entity = FromXml<YourStrongTypedEntity>(YourMsgString);

Exécutez simplement votre Visual Studio 2013 en tant qu'administration ... Copiez le contenu de votre fichier Xml. Allez dans Visual Studio 2013> Edition> Collage spécial> Coller Xml en tant que classes C #. Il créera vos classes c # en fonction du contenu de votre fichier Xml.

Juste au cas où quelqu'un trouverait cela utile:

public static class XmlConvert
{
    public static string SerializeObject<T>(T dataObject)
    {
        if (dataObject == null)
        {
            return string.Empty;
        }
        try
        {
            using (StringWriter stringWriter = new System.IO.StringWriter())
            {
                var serializer = new XmlSerializer(typeof(T));
                serializer.Serialize(stringWriter, dataObject);
                return stringWriter.ToString();
            }
        }
        catch (Exception ex)
        {
            return string.Empty;
        }
    }

    public static T DeserializeObject<T>(string xml)
         where T : new()
    {
        if (string.IsNullOrEmpty(xml))
        {
            return new T();
        }
        try
        {
            using (var stringReader = new StringReader(xml))
            {
                var serializer = new XmlSerializer(typeof(T));
                return (T)serializer.Deserialize(stringReader);
            }
        }
        catch (Exception ex)
        {
            return new T();
        }
    }
}

Vous pouvez l'appeler en utilisant:

MyCustomObject myObject = new MyCustomObject();
string xmlString = XmlConvert.SerializeObject(myObject)
myObject = XmlConvert.DeserializeObject<MyCustomObject>(xmlString);

Vous pouvez générer des classes comme décrit ci-dessus, ou les écrire manuellement:

[XmlRoot("msg")]
public class Message
{
    [XmlElement("id")]
    public string Id { get; set; }
    [XmlElement("action")]
    public string Action { get; set; }
}

Ensuite, vous pouvez utiliser ExtendedXmlSerializer pour sérialiser et désérialiser.

Instalation Vous pouvez installer ExtendedXmlSerializer à partir NuGet ou exécutez la commande suivante:

Install-Package ExtendedXmlSerializer

Sérialisation:

var serializer = new ConfigurationContainer().Create();
var obj = new Message();
var xml = serializer.Serialize(obj);

Désérialisation

var obj2 = serializer.Deserialize<Message>(xml);

Ce sérialiseur prend en charge:

• Désérialisation XML à partir de XMLSerializer standard
• Classe de sérialisation, struct, classe générique, type primitif, liste et dictionnaire génériques, tableau, enum
• Classe de sérialisation avec interface de propriété
• Référence circulaire de sérialisation et ID de référence
• Désérialisation de l'ancienne version de xml
• Cryptage de propriété
• Sérialiseur personnalisé
• Prise en charge de XmlElementAttribute et XmlRootAttribute
• POCO - toutes les configurations (migrations, sérialiseur personnalisé ...) sont en dehors de la classe

ExtendedXmlSerializer prend en charge .NET 4.5 ou version ultérieure et .NET Core . Vous pouvez l'intégrer avec WebApi et AspCore.

Vous pouvez utiliser xsd.exe pour créer des classes liées au schéma dans .Net puis XmlSerializer pour désérialiser la chaîne: http://msdn.microsoft.com/en-us/library/system.xml.serialization.xmlserializer.deserialize.aspx

Simplifier la grande réponse de Damian,

public static T ParseXml<T>(this string value) where T : class
{
    var xmlSerializer = new XmlSerializer(typeof(T));
    using (var textReader = new StringReader(value))
    {
        return (T) xmlSerializer.Deserialize(textReader);
    }
}

Je sais que cette question est ancienne, mais je suis tombé dessus et j'ai une réponse différente de celle de tous les autres :-)

La manière habituelle (comme le mentionnent les commentateurs ci-dessus) est de générer une classe et de désérialiser votre xml.

Mais ( attention: auto-promotion éhontée ici ) Je viens de publier un paquet nuget, ici , avec lequel vous n'avez pas à le faire. Allez simplement:

string xml = System.IO.File.ReadAllText(@"C:\test\books.xml");
var book = Dandraka.XmlUtilities.XmlSlurper.ParseText(xml);

C'est littéralement ça, rien d'autre n'est nécessaire. Et, plus important encore, si votre XML change, votre objet change également automatiquement.

Si vous préférez télécharger la dll directement, la page github est ici .

Créer un DTO en tant que CustomObject

Utilisez la méthode ci-dessous pour convertir la chaîne XML en DTO à l'aide de JAXB

private static CustomObject getCustomObject(final String ruleStr) {
    CustomObject customObject = null;
    try {
        JAXBContext jaxbContext = JAXBContext.newInstance(CustomObject.class);
        final StringReader reader = new StringReader(ruleStr);
        Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
        customObject = (CustomObject) jaxbUnmarshaller.unmarshal(reader);
    } catch (JAXBException e) {
        LOGGER.info("getCustomObject parse error: ", e);
    }
    return customObject;
}

Si vous disposez du xsd du message xml, vous pouvez générer des classes c # à l'aide de l'outil .Net xsd.exe.

Ces classes .Net peuvent ensuite être utilisées pour générer le xml.

En plus des autres réponses ici, vous pouvez naturellement utiliser la classe XmlDocument , pour une lecture de type XML DOM, ou le XmlReader , lecteur à avance rapide uniquement, pour le faire "à la main".

Une autre façon avec un outil avancé de génération de classes xsd vers c #: xsd2code.com. Cet outil est très pratique et puissant. Il a beaucoup plus de personnalisation que l'outil xsd.exe de Visual Studio. Xsd2Code ++ peut être personnalisé pour utiliser des listes ou des tableaux et prend en charge de grands schémas avec de nombreuses instructions d'importation.

Note de quelques fonctionnalités,

• Génère des objets métier à partir d'un schéma XSD ou d'un fichier XML vers du code C # flexible ou Visual Basic.
• Support Framework 2.0 à 4.x
• Prise en charge de la collection typée forte (List, ObservableCollection, MyCustomCollection).
• Prend en charge les propriétés automatiques.
• Générer des méthodes de lecture et d'écriture XML (sérialisation / désérialisation).
• Prise en charge de la liaison de données (WPF, Xamarin).
• WCF (attribut DataMember).
• Prise en charge du codage XML (UTF-8/32, ASCII, Unicode, personnalisé).
• Support de cas Camel / Pascal Case.
• prise en charge des restrictions ([StringLengthAttribute = true / false], [RegularExpressionAttribute = true / false], [RangeAttribute = true / false]).
• Prend en charge les fichiers XSD volumineux et complexes.
• Prise en charge de DotNet Core et standard

J'ai parcouru toutes les réponses à cette date (2020-07-24), et il doit y avoir un moyen plus simple et plus familier de résoudre ce problème, qui est le suivant.

Deux scénarios ... L'un est si la chaîne XML est bien formée , c'est -à- dire qu'elle commence par quelque chose comme <?xml version="1.0" encoding="utf-16"?>ou ses semblables, avant de rencontrer l'élément racine, qui est <msg>dans la question. L'autre est s'il n'est PAS bien formé , c'est-à-dire uniquement l'élément racine (par exemple <msg>dans la question) et ses nœuds enfants uniquement.

Tout d'abord, juste une classe simple qui contient les propriétés qui correspondent, dans les noms insensibles à la casse, aux nœuds enfants du nœud racine dans le XML. Donc, d'après la question, ce serait quelque chose comme ...

public class TheModel
{
    public int Id { get; set; }
    public string Action { get; set; }
}

Ce qui suit est le reste du code ...

// These are the key using statements to add.
using Newtonsoft.Json;
using System.Xml;

bool isWellFormed = false;
string xml =  = @"
<msg>
   <id>1</id>
   <action>stop</action>
</msg>
";

var xmlDocument = new XmlDocument();
xmlDocument.LoadXml(xml);
if (isWellFormed)
{
    xmlDocument.RemoveChild(xmlDocument.FirstChild); 
    /* i.e. removing the first node, which is the declaration part. 
    Also, if there are other unwanted parts in the XML, 
    write another similar code to locate the nodes 
    and remove them to only leave the desired root node 
    (and its child nodes).*/
}

var serializedXmlNode = JsonConvert.SerializeXmlNode(
            xmlDocument, 
            Newtonsoft.Json.Formatting.Indented, 
            true
            );
var theDesiredObject = JsonConvert.DeserializeObject<TheModel>(serializedXmlNode);

public string Serialize<T>(T settings)
{
    XmlSerializer serializer = new XmlSerializer(typeof(T));
    StringWriter outStream = new StringWriter();
    serializer.Serialize(outStream, settings);
    return outStream.ToString();
}