Convertir une chaîne de caractères XML en objet

Vous avez deux possibilités.

Méthode 1. XSD tool

---

Supposons que vous ayez votre fichier XML à cet endroit C:\path\to\xml\file.xml

1. Ouvrir Développeur Invite De Commande
   
   Vous pouvez le trouver dans Start Menu > Programs > Microsoft Visual Studio 2012 > Visual Studio Tools Ou si vous avez Windows 8 peut juste commencer à taper invite de commande de développeur dans é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éer fichier XSD à partir de votre fichier xml en tapant xsd file.xml
4. créer C # classes en tapant xsd /c file.xsd

et c'est tout! Vous avez généré des classes C# à partir du fichier xml dans C:\path\to\xml\file.cs

Méthode 2-Pâte spéciale

---

Requis Visual Studio 2012+ avec .net Framework > = 4.5 comme cible du projet

1. copier le contenu de votre fichier XML dans le presse-papiers
2. ajouter à votre solution un nouveau fichier de classe vide ( Maj + Alt + C )
3. ouvrir ce fichier et dans le menu cliquer Edit > Paste special > Paste XML As Classes
   
   

et c'est tout!

Utilisation

---

L'Usage est très simple avec cette classe d'aide:

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 Xml en objet. Il est fait pour exactement 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 ;        
}

L'appeler en utilisant ce code:

YourStrongTypedEntity entity = FromXml<YourStrongTypedEntity>(YourMsgString);

exécutez simplement votre studio visuel 2013 en tant qu'Administration ... Copiez le contenu de votre fichier Xml.. Aller à Visual Studio 2013 > Édition > collage Spécial > Coller Xml en tant que Classes C# Il créera vos classes c# Selon le contenu de votre fichier Xml.

Juste au cas où quelqu'un pourrait trouver 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 utiliser xsd.exe pour créer des classes liées à schema dans .Net puis XmlSerializer pour désérialiser la chaîne: http://msdn.microsoft.com/en-us/library/system.xml.serialization.xmlserializer.deserialize.aspx

vous pouvez générer la classe 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; }
}

alors vous pouvez utiliser ExtendedXmlSerializer pour sérialiser et deserialiser.

Instalation Vous pouvez installer ExtendedXmlSerializer à partir de nuget ou exécuter 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 support de sérialiseur:

• la Désérialisation xml de la norme XMLSerializer
• Sérialisation de la classe, struct, classe générique, type primitif, liste générique et dictionnaire, tableau, enum
• Sérialisation de la classe avec la propriété de l'interface
• Serialization référence circulaire et référence Id
• Deserialisation de l'ancienne version de xml
"1519290920 de la Propriété" cryptage
• Personnalisé sérialiseur
• Soutien XmlElementAttribute et attribut xmlrootattribute
• POCO - toutes les configurations (migrations, sérialiseur personnalisé...) ne relèvent pas de la classe

ExtendedXmlSerializer support .NET 4.5 or higher et .NET Core . Vous pouvez l'intégrer avec WebApi et AspCore.

si vous avez le xsd du message xml, vous pouvez générer des classes c# en utilisant le .Net xsd.exe outil.

cette classe .Net peut alors être utilisée pour générer le xml.

en plus des autres réponses ici, vous pouvez naturellement utiliser la classe XmlDocument , pour la lecture de type DOM XML , ou le XmlReader , lecteur forward-only rapide, pour le faire"à la main".

simplifiant 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);
    }
}

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