Konwertuj ciąg XML na obiekt

Otrzymuję ciągi XML przez gniazdo i chciałbym przekonwertować je na obiekty C #.

Wiadomości mają postać:

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

Jestem nowy w .Net i nie jestem pewien najlepszych praktyk w tym zakresie. Wcześniej korzystałem z JAXB dla Javy i nie byłem pewien, czy istnieje coś podobnego, czy też byłoby inaczej.

Musisz użyć xsd.exenarzędzia instalowanego wraz z zestawem Windows SDK w katalogu podobnym do:

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

I na komputerach 64-bitowych:

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

A na komputerach z systemem Windows 10:

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

Przy pierwszym uruchomieniu używasz xsd.exei konwertujesz przykładowy plik XML na plik XSD (plik schematu XML):

xsd yourfile.xml

To daje ci yourfile.xsd, co w drugim kroku, możesz ponownie przekonwertować za xsd.exepomocą klasy C #:

xsd yourfile.xsd /c

To powinno dać ci plik, yourfile.csktóry będzie zawierał klasę C #, której możesz użyć do deserializacji otrzymanego pliku XML - coś takiego:

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

Powinien działać całkiem dobrze w większości przypadków.

Aktualizacja: serializator XML pobierze dowolny strumień jako dane wejściowe - strumień pliku lub pamięci będzie w porządku:

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

lub użyj StringReader:

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

Masz dwie możliwości.

Metoda 1. Narzędzie XSD

1. Otwórz wiersz polecenia programisty
   Możesz 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ąć pisać wiersz polecenia programisty na ekranie Start
2. Zmień lokalizację na katalog plików XML, wpisując cd /D "C:\path\to\xml"
3. Utwórz plik XSD z pliku xml, wpisującxsd file.xml
4. Utwórz klasy C # , wpisującxsd /c file.xsd

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

Metoda 2 - Wklej specjalnie

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 kliknij menu Edit > Paste special > Paste XML As Classes
   

I to wszystko!

Stosowanie

Użycie tej klasy pomocniczej jest bardzo proste:

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

Zadzwoń, 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> Edytuj> Wklej specjalnie> Wklej Xml jako klasy C # Stworzy on twoje klasy c # zgodnie z zawartością pliku Xml.

Na 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żesz to nazwać za pomocą:

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

Możesz wygenerować klasę zgodnie z powyższym opisem 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ącą komendę:

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 serializatora:

• Deserializacja xml ze standardowego XMLSerializer
• Klasa szeregowania, struct, klasa ogólna, typ pierwotny, lista ogólna i słownik, tablica, wyliczanie
• Klasa serializacji z interfejsem właściwości
• Numer referencyjny okólnika serializacji i identyfikator referencyjny
• Deserializacja starej wersji xml
• Szyfrowanie własności
• Niestandardowy serializator
• Obsługa XmlElementAttribute i XmlRootAttribute
• POCO - wszystkie konfiguracje (migracje, niestandardowy serializator ...) są poza klasą

Obsługa ExtendedXmlSerializer .NET 4.5 lub nowszy i .NET Core . Możesz zintegrować go z WebApi i AspCore.

Za pomocą narzędzia xsd.exe można tworzyć klasy powiązane ze schematem w .Net, a następnie XmlSerializer w celu deserializacji ciągu: http://msdn.microsoft.com/en-us/library/system.xml.serialization.xmlserializer.deserialize.aspx

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

Utwórz DTO jako CustomObject

Użyj poniższej metody, aby przekonwertować ciąg XML na DTO przy użyciu 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;
}

Jeśli masz xsd wiadomości xml, możesz wygenerować klasy c # za pomocą narzędzia .Net xsd.exe.

Tych klas .Net można następnie użyć do wygenerowania pliku XML.

Oprócz innych odpowiedzi tutaj możesz oczywiście użyć klasy XmlDocument do odczytu podobnego do DOM XML lub XmlReader , szybkiego czytnika tylko do przodu, aby zrobić to „ręcznie”.

Innym sposobem jest Zaawansowane generowanie klas xsd do c # Narzędzia: xsd2code.com. To narzędzie jest bardzo przydatne i wydajne. Ma o wiele więcej dostosowań niż narzędzie xsd.exe z Visual Studio. Xsd2Code ++ można dostosować do korzystania z list lub tablic i obsługuje duże schematy z dużą ilością instrukcji importu.

Uwaga niektórych funkcji,

• Generuje obiekty biznesowe ze schematu XSD lub pliku XML do elastycznego kodu C # lub Visual Basic.
• Support Framework 2.0 do 4.x
• Obsługuje silną kolekcję typów (List, ObservableCollection, MyCustomCollection).
• Obsługuje właściwości automatyczne.
• Generuj metody odczytu i zapisu XML (serializacja / deserializacja).
• Obsługa wiązania danych (WPF, Xamarin).
• WCF (atrybut DataMember).
• Obsługa kodowania XML (UTF-8/32, ASCII, Unicode, Custom).
• Obsługa futerału na wielbłądy / Pascala.
• obsługa ograniczeń ([StringLengthAttribute = true / false], [RegularExpressionAttribute = true / false], [RangeAttribute = true / false]).
• Obsługuje duży i złożony plik XSD.
• Obsługa DotNet Core i standardu

Wiem, że to pytanie jest stare, ale natknąłem się na nie i mam inną odpowiedź niż cóż, wszyscy inni :-)

Zwykłym sposobem (jak wspomniano powyżej komentatorzy) jest wygenerowanie klasy i usunięcie serializacji pliku xml.

Ale ( uwaga: bezwstydny autopromocji tutaj ) właśnie opublikowała pakiet Nuget, tutaj , z którą nie trzeba. Po prostu idź:

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

To dosłownie tyle, nic więcej nie jest potrzebne. A co najważniejsze, jeśli twój xml się zmieni, twój obiekt również zmieni się automatycznie.

Jeśli wolisz pobrać dll bezpośrednio, strona github jest tutaj .

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