Converter o texto XML para objecto

Método 1. XSD Ferramenta

1. Abrir A Linha De Comandos Do Programador
   Você pode encontrá-lo em Start Menu > Programs > Microsoft Visual Studio 2012 > Visual Studio Tools Ou se tiver o Windows 8 pode começar a escrever a linha de comandos do programador em o ecrã inicial
2. mude a localização para a sua pasta de ficheiros XML, escrevendo cd /D "C:\path\to\xml"
3. criar ficheiro XSD a partir do seu xml ficheiro ao escrever xsd file.xml
4. criar C # classes {[14] } escrevendo xsd /c file.xsd

Método 2-pasta especial

1. copiar o conteúdo do seu ficheiro XML para a área de transferência
2. adicione à sua solução um novo ficheiro de classe vazio ( Shift+Alt+C)
Abre esse ficheiro. e no menu carregue Edit > Paste special > Paste XML As Classes

Utilização

O uso é muito simples com esta classe auxiliar:

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

Tudo o que tens de fazer agora, é:

    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>();

Tente este método para converter Xml para um objecto. É feito exatamente para o que você está fazendo:

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

Chama-o usando este código:

YourStrongTypedEntity entity = FromXml<YourStrongTypedEntity>(YourMsgString);

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

Podes chamá-lo usando:

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

Pode usar xsd.exe para criar classes de encadernação do esquema em. Net então o Xmlserializador para Deserializar o texto : http://msdn.microsoft.com/en-us/library/system.xml.serialization.xmlserializer.deserialize.aspx

Pode gerar a classe acima descrita, ou escrevê-la manualmente:

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

Então você pode usar ExtendedXmlSerializer para serializar e deserializar.

Instalação Pode instalar o ExtendedXmlSerializer a partir de nuget ou executar o seguinte comando:

Install-Package ExtendedXmlSerializer

Serialização:

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

Deserialização

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

Este suporte de serialização:

• Deserialização xml de standard XMLSerializer
• Classe de serialização, estrutura, classe genérica, tipo primitivo, lista genérica e dicionário, array, enum
• Classe de serialização com interface de propriedade
• referência circular de serialização e Id de referência
• Deserialização da versão antiga do xml
• encriptação da propriedade
• serializador personalizado
• suporte XmlElement attribute e XmlRootAttribute
• POCO-todas as configurações (migrações, personalização serializador...) estão fora da classe

Suporte Extendedxmlserializador . net 4. 5 ou superior e núcleo de rede . Você pode integrá-lo com WebApi e AspCore.

Se tiver o xsd da mensagem xml, então poderá gerar classes C# usando o xsd. Net.exe tool.

Estas classes. Net podem então ser usadas para gerar o xml.

Para além das outras respostas aqui, poderá utilizar naturalmente a classe XmlDocument, para leitura em formato de DOM XML, ou o XmlReader, Leitor avançado apenas, para o fazer "à mão".

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