Konwertuj Łańcuch XML na obiekt

Masz dwie możliwości.

Metoda 1. XSD narzędzie

1. Open Developer Command Prompt
   Można go znaleźć w Start Menu > Programs > Microsoft Visual Studio 2012 > Visual Studio Tools Lub jeśli masz System Windows 8, możesz po prostu zacząć wpisywać Wiersz polecenia programisty w ekran startowy
2. Zmień lokalizację w katalogu plików XML wpisując cd /D "C:\path\to\xml"
3. Utwórz plik XSD z pliku xml wpisując xsd file.xml
4. Utwórz klasy C# wpisując xsd /c file.xsd

I to wszystko! Wygenerowałeś klasy C# z pliku xml w C:\path\to\xml\file.cs

Metoda 2-wklej specjalne

1. Skopiuj zawartość pliku XML do schowka
2. Dodaj do swojego rozwiązania nowy, pusty plik klasy (Shift+Alt+C )
3. otwórz ten plik i w menu kliknij Edit > Paste special > Paste XML As Classes
   

I to wszystko!

Użycie

Użycie jest bardzo proste z tą klasą pomocniczą:

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

Wszystko, co musisz teraz zrobić, to:

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

Wypróbuj tę metodę, aby przekonwertować Xml na obiekt. Jest stworzony do tego, co robisz:

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

Wywołaj to używając tego kodu:

YourStrongTypedEntity entity = FromXml<YourStrongTypedEntity>(YourMsgString);

Po prostu uruchom Visual Studio 2013 jako Administracja ... Skopiuj zawartość pliku Xml.. Przejdź do Visual Studio 2013 > Edycja > Wklej specjalne > Wklej Xml jako klasy C# Stworzy Twoje klasy c# zgodnie z zawartością Twojego pliku Xml.

Na wszelki wypadek, gdyby ktoś uznał to za przydatne:

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

Można go nazwać używając:

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

Możesz użyć xsd.exe do tworzenia klas związanych ze schematem w. Net następnie XmlSerializer do deserializacji łańcucha: http://msdn.microsoft.com/en-us/library/system.xml.serialization.xmlserializer.deserialize.aspx

Możesz wygenerować klasę w sposób opisany powyżej, lub napisać ją ręcznie:

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

Następnie możesz użyć ExtendedXmlSerializer do serializacji i deserializacji.

Instalacja Możesz zainstalować ExtendedXmlSerializer z nuget lub uruchomić następujące polecenie:

Install-Package ExtendedXmlSerializer

Serializacja:

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

Deserializacja

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

Obsługa tego serializera:

• Deserializacja xml ze standardu XMLSerializer
• Klasa serializacji, struktura, Klasa uniwersalna, Typ prymitywny, lista uniwersalna i słownik, tablica, wyliczenie
• Klasa serializacji z interfejsem właściwości
• Serialization circular reference and reference Id
• Deserializacja starej wersji xml
• Szyfrowanie własności
• Custom serializer
• Obsługa XmlElementAttribute i XmlRootAttribute
• POCO-wszystkie konfiguracje (migracje, Niestandardowy serializer...) są poza klasą

ExtendedXmlSerializer support . NET 4.5 lub wyższy i . Net Core. Możesz go zintegrować z WebApi i AspCore.

Jeśli masz XSD z wiadomości xml, możesz wygenerować klasy c# używając. Net xsd.narzędzie exe.

Te klasy. Net mogą być następnie użyte do wygenerowania XML.

Oprócz innych odpowiedzi tutaj można oczywiście użyć klasy XmlDocument, do odczytu przypominającego DOM XML, lub XmlReader, Czytnik tylko do szybkiego przewijania do przodu, aby zrobić to "ręcznie".

Upraszczając świetną odpowiedź Damiana,

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