Je reçois des chaînes XML sur une socket et j'aimerais les convertir en objets C #.
Les messages sont de la forme:
<msg>
<id>1</id>
<action>stop</action>
</msg>
Je suis nouveau sur .Net et je ne suis pas sûr de la meilleure pratique pour effectuer cela. J'ai déjà utilisé JAXB pour Java, et je ne savais pas s'il y avait quelque chose de similaire ou si cela serait géré d'une manière différente.
Réponses:
Vous devez utiliser l'
xsd.exe
outil qui est installé avec le SDK Windows dans un répertoire similaire à:C:\Program Files\Microsoft SDKs\Windows\v6.0A\bin
Et sur les ordinateurs 64 bits:
C:\Program Files (x86)\Microsoft SDKs\Windows\v6.0A\bin
Et sur les ordinateurs Windows 10:
C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\bin
Lors de la première exécution, vous utilisez
xsd.exe
et vous convertissez votre exemple de XML en un fichier XSD (fichier de schéma XML):xsd yourfile.xml
Cela vous donne
yourfile.xsd
, que dans un deuxième temps, vous pouvez convertir à nouveau en utilisantxsd.exe
une classe C #:xsd yourfile.xsd /c
Cela devrait vous donner un fichier
yourfile.cs
qui contiendra une classe C # que vous pouvez utiliser pour désérialiser le fichier XML que vous obtenez - quelque chose comme:XmlSerializer serializer = new XmlSerializer(typeof(msg)); msg resultingMessage = (msg)serializer.Deserialize(new XmlTextReader("yourfile.xml"));
Cela devrait plutôt bien fonctionner dans la plupart des cas.
Mise à jour: le sérialiseur XML prendra n'importe quel flux comme entrée - un fichier ou un flux mémoire conviendra:
XmlSerializer serializer = new XmlSerializer(typeof(msg)); MemoryStream memStream = new MemoryStream(Encoding.UTF8.GetBytes(inputString)); msg resultingMessage = (msg)serializer.Deserialize(memStream);
ou utilisez un StringReader:
XmlSerializer serializer = new XmlSerializer(typeof(msg)); StringReader rdr = new StringReader(inputString); msg resultingMessage = (msg)serializer.Deserialize(rdr);
la source
Vous avez deux possibilités.
Méthode 1. Outil XSD
Supposons que vous ayez votre fichier XML à cet emplacement
C:\path\to\xml\file.xml
Vous pouvez le trouver dans
Start Menu > Programs > Microsoft Visual Studio 2012 > Visual Studio Tools
Ou si vous avez Windows 8, vous pouvez simplement commencer à taper l' invite de commande du développeur dans l' écran de démarragecd /D "C:\path\to\xml"
xsd file.xml
xsd /c file.xsd
Et c'est tout! Vous avez généré des classes C # à partir d'un fichier xml dans
C:\path\to\xml\file.cs
Méthode 2 - Collage spécial
Visual Studio 2012+ requis avec .Net Framework> = 4.5 en tant que cible du projet et composant individuel «Windows Communication Foundation» installé
Edit > Paste special > Paste XML As Classes
Et c'est tout!
Usage
L'utilisation est très simple avec cette classe d'assistance:
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>();
la source
Essayez cette méthode pour convertir du XML en objet. Il est fait exactement pour 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 ; }
Appelez-le en utilisant ce code:
YourStrongTypedEntity entity = FromXml<YourStrongTypedEntity>(YourMsgString);
la source
Exécutez simplement votre Visual Studio 2013 en tant qu'administration ... Copiez le contenu de votre fichier Xml. Allez dans Visual Studio 2013> Edition> Collage spécial> Coller Xml en tant que classes C #. Il créera vos classes c # en fonction du contenu de votre fichier Xml.
la source
Juste au cas où quelqu'un trouverait 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);
la source
Vous pouvez générer des classes 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; } }
Ensuite, vous pouvez utiliser ExtendedXmlSerializer pour sérialiser et désérialiser.
Instalation Vous pouvez installer ExtendedXmlSerializer à partir NuGet ou exécutez 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 sérialiseur prend en charge:
ExtendedXmlSerializer prend en charge .NET 4.5 ou version ultérieure et .NET Core . Vous pouvez l'intégrer avec WebApi et AspCore.
la source
Vous pouvez utiliser xsd.exe pour créer des classes liées au schéma dans .Net puis XmlSerializer pour désérialiser la chaîne: http://msdn.microsoft.com/en-us/library/system.xml.serialization.xmlserializer.deserialize.aspx
la source
Simplifier 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); } }
la source
Je sais que cette question est ancienne, mais je suis tombé dessus et j'ai une réponse différente de celle de tous les autres :-)
La manière habituelle (comme le mentionnent les commentateurs ci-dessus) est de générer une classe et de désérialiser votre xml.
Mais ( attention: auto-promotion éhontée ici ) Je viens de publier un paquet nuget, ici , avec lequel vous n'avez pas à le faire. Allez simplement:
string xml = System.IO.File.ReadAllText(@"C:\test\books.xml"); var book = Dandraka.XmlUtilities.XmlSlurper.ParseText(xml);
C'est littéralement ça, rien d'autre n'est nécessaire. Et, plus important encore, si votre XML change, votre objet change également automatiquement.
Si vous préférez télécharger la dll directement, la page github est ici .
la source
Utilisez la méthode ci-dessous pour convertir la chaîne XML en DTO à l'aide de 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; }
la source
Si vous disposez du xsd du message xml, vous pouvez générer des classes c # à l'aide de l'outil .Net xsd.exe.
Ces classes .Net peuvent ensuite être utilisées pour générer le xml.
la source
En plus des autres réponses ici, vous pouvez naturellement utiliser la classe XmlDocument , pour une lecture de type XML DOM, ou le XmlReader , lecteur à avance rapide uniquement, pour le faire "à la main".
la source
Une autre façon avec un outil avancé de génération de classes xsd vers c #: xsd2code.com. Cet outil est très pratique et puissant. Il a beaucoup plus de personnalisation que l'outil xsd.exe de Visual Studio. Xsd2Code ++ peut être personnalisé pour utiliser des listes ou des tableaux et prend en charge de grands schémas avec de nombreuses instructions d'importation.
Note de quelques fonctionnalités,
la source
J'ai parcouru toutes les réponses à cette date (2020-07-24), et il doit y avoir un moyen plus simple et plus familier de résoudre ce problème, qui est le suivant.
Deux scénarios ... L'un est si la chaîne XML est bien formée , c'est -à- dire qu'elle commence par quelque chose comme
<?xml version="1.0" encoding="utf-16"?>
ou ses semblables, avant de rencontrer l'élément racine, qui est<msg>
dans la question. L'autre est s'il n'est PAS bien formé , c'est-à-dire uniquement l'élément racine (par exemple<msg>
dans la question) et ses nœuds enfants uniquement.Tout d'abord, juste une classe simple qui contient les propriétés qui correspondent, dans les noms insensibles à la casse, aux nœuds enfants du nœud racine dans le XML. Donc, d'après la question, ce serait quelque chose comme ...
public class TheModel { public int Id { get; set; } public string Action { get; set; } }
Ce qui suit est le reste du code ...
// These are the key using statements to add. using Newtonsoft.Json; using System.Xml; bool isWellFormed = false; string xml = = @" <msg> <id>1</id> <action>stop</action> </msg> "; var xmlDocument = new XmlDocument(); xmlDocument.LoadXml(xml); if (isWellFormed) { xmlDocument.RemoveChild(xmlDocument.FirstChild); /* i.e. removing the first node, which is the declaration part. Also, if there are other unwanted parts in the XML, write another similar code to locate the nodes and remove them to only leave the desired root node (and its child nodes).*/ } var serializedXmlNode = JsonConvert.SerializeXmlNode( xmlDocument, Newtonsoft.Json.Formatting.Indented, true ); var theDesiredObject = JsonConvert.DeserializeObject<TheModel>(serializedXmlNode);
la source
public string Serialize<T>(T settings) { XmlSerializer serializer = new XmlSerializer(typeof(T)); StringWriter outStream = new StringWriter(); serializer.Serialize(outStream, settings); return outStream.ToString(); }
la source