it-swarm.com.de

Konvertieren Sie den XML-String in ein Objekt

Ich erhalte XML-Strings über einen Socket und möchte diese in C # -Objekte konvertieren.

Die Nachrichten haben die Form:

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

Ich bin neu bei .Net und bin mir nicht sicher, ob dies der beste Weg ist. Ich habe JAXB bereits für Java verwendet und war mir nicht sicher, ob es etwas Ähnliches gibt oder ob dies anders gehandhabt wird.

139
Steve

Sie müssen das xsd.exe-Tool verwenden, das mit dem Windows SDK in einem Verzeichnis wie dem folgenden installiert wird: 

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

Und auf 64-Bit-Computern:

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

Und auf Windows 10-Computern:

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

Beim ersten Durchlauf verwenden Sie xsd.exe und konvertieren Ihre Beispiel-XML in eine XSD-Datei (XML-Schemadatei):

xsd yourfile.xml

Dadurch erhalten Sie yourfile.xsd, die Sie in einem zweiten Schritt erneut mit xsd.exe in eine C # -Klasse konvertieren können:

xsd yourfile.xsd /c

Dies sollte Ihnen eine Datei yourfile.cs geben, die eine C # -Klasse enthält, mit der Sie die XML-Datei, die Sie erhalten, deserialisieren können.

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

Sollte für die meisten Fälle ziemlich gut funktionieren.

Update: Der XML-Serialisierer nimmt einen beliebigen Stream als Eingabe - entweder eine Datei oder ein Speicher-Stream ist in Ordnung:

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

oder benutze einen StringReader:

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

Verwenden Sie diese Methode, um XML in ein Objekt zu konvertieren. Es ist genau für das gemacht, was Sie tun:

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

Nennen Sie es mit diesem Code:

YourStrongTypedEntity entity = FromXml<YourStrongTypedEntity>(YourMsgString);
41
RJ.

Führen Sie einfach Ihr Visual Studio 2013 als Administration aus ....__ Kopieren Sie den Inhalt Ihrer XML-Datei .. Gehen Sie zu Visual Studio 2013> Bearbeiten> Inhalte einfügen> XML als C # -Klassen einfügen. Klassen entsprechend Ihrem Inhalt der XML-Datei. 

8
user2667652

Nur für den Fall, dass jemand dies nützlich finden könnte:

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

Sie können es aufrufen mit:

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

Sie können eine Klasse wie oben beschrieben generieren oder manuell schreiben:

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

Dann können Sie ExtendedXmlSerializer zum Serialisieren und Deserialisieren verwenden.

Instalation Sie können ExtendedXmlSerializer von nuget installieren oder den folgenden Befehl ausführen:

Install-Package ExtendedXmlSerializer

Serialisierung:

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

Deserialisierung

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

Diese Serializer-Unterstützung:

  • Deserialisierungs-XML aus Standard-XMLSerializer
  • Serialisierungsklasse, Struktur, generische Klasse, primitiver Typ, generische Liste und Wörterbuch, Array, Enum
  • Serialisierungsklasse mit Eigenschaftsschnittstelle
  • Serialisierungs-Zirkelreferenz und Referenz-ID
  • Deserialisierung der alten Version von XML
  • Eigenschaftsverschlüsselung
  • Benutzerdefinierter Serializer
  • Unterstützt XmlElementAttribute und XmlRootAttribute
  • POCO - alle Konfigurationen (Migrationen, benutzerdefinierte Serialisierer ...) liegen außerhalb der Klasse

ExtendedXmlSerializer unterstützt .NET 4.5 oder höher und .NET Core. Sie können es mit WebApi und AspCore integrieren. 

2
Wojtpl2

Sie können xsd.exe verwenden, um schemabezogene Klassen in .Net zu erstellen, und dann XmlSerializer, um die Zeichenfolge zu deserialisieren: http://msdn.Microsoft.com/en-us/library/system.xml.serialization.xmlserializer.deserialize.aspx

2
DaveShaw

Wenn Sie die xsd der XML-Nachricht haben, können Sie mit dem .Net xsd.exe-Tool c # -Klassen erstellen.

Diese .Net-Klassen können dann zum Generieren der XML verwendet werden.

0
Amitabh

Ich weiß, dass diese Frage alt ist, aber ich bin darauf gestoßen und habe eine andere Antwort als alle anderen :-)

Der übliche Weg (wie die oben erwähnten Kommentatoren) besteht darin, eine Klasse zu generieren und Ihre XML-Datei zu deserialisieren.

Aber ( Warnung: Schamlose Eigenwerbung hier ) Ich habe gerade ein Nuget-Paket veröffentlicht, hier , mit dem Sie nicht müssen, zu ... haben. Du gehst einfach:

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

Das ist buchstäblich nichts anderes nötig. Und vor allem, wenn sich Ihre XML-Datei ändert, ändert sich Ihr Objekt auch automatisch.

Wenn Sie es vorziehen, die DLL direkt herunterzuladen, ist die Github-Seite hier .

0
Jim Andrakakis

Zusätzlich zu den anderen Antworten können Sie natürlich die Klasse XmlDocument für XML - DOM - ähnliches Lesen verwenden oder den XmlReader , den schnellen Vorwärtsleser, um "von Hand" zu tun.

0
Skurmedel

Damians großartige Antwort zu vereinfachen,

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);
    }
}
0
Sam Jazz

Eine andere Möglichkeit mit einer erweiterten Xsd-Klasse zur Erzeugung von C # -Klassen: xsd2code.com. Dieses Tool ist sehr praktisch und leistungsstark. Es hat viel mehr Anpassungen als das Tool xsd.exe von Visual Studio. Xsd2Code ++ kann für die Verwendung von Listen oder Arrays angepasst werden und unterstützt große Schemas mit vielen Importanweisungen.

Hinweis auf einige Funktionen,

  • Generiert Geschäftsobjekte aus XSD-Schema oder XML-Datei in flexiblem C # Oder Visual Basic-Code.
  • Support Framework 2.0 bis 4.x
  • Unterstützt eine stark typisierte Sammlung (List, ObservableCollection, MyCustomCollection).
  • Automatische Eigenschaften unterstützen.
  • Generieren Sie XML-Lese- und Schreibmethoden (Serialisierung/Deserialisierung).
  • Datenbindungsunterstützung (WPF, Xamarin).
  • WCF (DataMember-Attribut).
  • Unterstützung für XML-Kodierung (UTF-8/32, ASCII, Unicode, Benutzerdefiniert).
  • Camel Case/Pascal Case Unterstützung.
  • einschränkungsunterstützung ([StringLengthAttribute = true/false], [RegularExpressionAttribute = true/false], [RangeAttribute = true/false]).
  • Unterstützt große und komplexe XSD-Dateien.
  • Unterstützung von DotNet Core & Standard
0
Haas Franck