Désérialiser XML en objet en C#

Abdullahi Salawudeen 15 février 2024 Csharp Csharp Object
  1. Utiliser des classes typées manuellement pour désérialiser le fichier XML en objet C#
  2. Utilisez la fonction Paste Special de Visual Studio pour désérialiser l’objet Xml en C#
  3. Utilisez l’outil XSD pour désérialiser le XML en objet C#
Désérialiser XML en objet en C#

Cet article va démontrer la conversion ou la désérialisation des fichiers XML dans l’objet C#.

Utiliser des classes typées manuellement pour désérialiser le fichier XML en objet C#

  • C# est associé à des classes et des objets ainsi qu’à des attributs et des méthodes.
  • Les Objets sont représentés par des classes par programmation, telles que John ou James.
  • Les attributs sont des caractéristiques d’objets telles que la couleur d'une voiture, l'année de production, l'âge d'une personne ou la couleur d'un bâtiment.
  • XML est le format normalisé qui permet d’analyser les données XML quel que soit le support de transmission du fichier XML.

Une discussion plus approfondie est disponible via cette référence.

Vous trouverez ci-dessous un exemple de code XML qui serait converti en un objet C#.

1. <?xml version="1.0" encoding="utf-8"?>
2. <Company xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="https://www.w3.org/2001/XMLSchema">
3.  <Employee name="x" age="30" />
4.  <Employee name="y" age="32" />
5. </Company>

Une classe avec une structure similaire serait créée en C# pour convertir l’exemple de code XML.

using System.Xml.Serialization;

[XmlRoot(ElementName = "Company")]
public class Company

{
  public Company() {
    Employees = new List<Employee>();
  }

  [XmlElement(ElementName = "Employee")]
  public List<Employee> Employees { get; set; }

  public Employee this[string name] {
    get {
      return Employees.FirstOrDefault(
          s => string.Equals(s.Name, name, StringComparison.OrdinalIgnoreCase));
    }
  }
}

public class Employee {
  [XmlAttribute("name")]
  public string Name { get; set; }

  [XmlAttribute("age")]
  public string Age { get; set; }
}

La dernière étape pour convertir l’objet XML en C# consiste à utiliser la fonction System.Xml.Serialization.XmlSerializer pour sérialiser l’objet.

public T DeserializeToObject<T>(string filepath)
    where T : class {
  System.Xml.Serialization.XmlSerializer ser =
      new System.Xml.Serialization.XmlSerializer(typeof(T));

  using (StreamReader sr = new StreamReader(filepath)) {
    return (T)ser.Deserialize(sr);
  }
}

Utilisez la fonction Paste Special de Visual Studio pour désérialiser l’objet Xml en C#

Cette méthode nécessite l’utilisation de Microsoft Visual Studio 2012 et supérieur avec .Net Framework 4.5 et supérieur. La charge de travail WCF pour Visual Studio doit également être installée.

  • Le contenu du document XML doit être copié dans le presse-papiers.
  • Ajouter une nouvelle classe empty à la solution du projet.
  • Ouvrez le nouveau fichier de classe.
  • Cliquez sur le bouton Modifier dans la barre de menu de l’IDE.
  • Sélectionnez Paste Special dans la liste déroulante.
  • Cliquez sur Coller XML comme classes.

Coller XML en tant que classes

Pour utiliser la classe générée par Visual Studio, créez la classe Helpers.

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

Utilisez l’outil XSD pour désérialiser le XML en objet C#

XSD est utilisé pour générer automatiquement des classes ou des objets équivalents au schéma défini dans un fichier ou un document XML.

XSD.exe se trouve normalement dans le chemin : C:\Program Files (x86)\Microsoft SDKs\Windows\{version}\bin\NETFX {version} Tools\. Une discussion plus approfondie est disponible via cette référence.

Supposons que le fichier XML est enregistré dans ce chemin : C:\X\test.XML.

Voici les étapes à suivre pour désérialiser automatiquement les classes XML vers C# :

  • Tapez Developer Command Prompt dans la barre de recherche et cliquez dessus pour l’ouvrir.
  • Tapez cd C:\X pour accéder au chemin du fichier XML.
  • Supprimez les numéros de ligne et tous les caractères inutiles dans le fichier XML.
  • Tapez xsd test.XML pour créer un fichier XSD équivalent à partir du test.XML.
  • Un fichier test.XSD est créé dans le même chemin de fichier.
  • Tapez XSD /c test.XSD pour créer les classes C# équivalentes au fichier XML.
  • Un fichier test.cs est créé, une classe C# avec un schéma exact du fichier XML.

Production:

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.42000
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

using System.Xml.Serialization;

//
// This source code was auto-generated by xsd, Version=4.8.3928.0.
//

/// <remarks/>
[System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")]
[System.SerializableAttribute()]
[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
[System.Xml.Serialization.XmlRootAttribute(Namespace="", IsNullable=false)]
public partial class Company {

    private CompanyEmployee[] itemsField;

    /// <remarks/>
    [System.Xml.Serialization.XmlElementAttribute("Employee", Form=System.Xml.Schema.XmlSchemaForm.Unqualified)]
    public CompanyEmployee[] Items {
        get {
            return this.itemsField;
        }
        set {
            this.itemsField = value;
        }
    }
}

/// <remarks/>
[System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.8.3928.0")]
[System.SerializableAttribute()]
[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
public partial class CompanyEmployee {

    private string nameField;

    private string ageField;

    /// <remarks/>
    [System.Xml.Serialization.XmlAttributeAttribute()]
    public string name {
        get {
            return this.nameField;
        }
        set {
            this.nameField = value;
        }
    }

    /// <remarks/>
    [System.Xml.Serialization.XmlAttributeAttribute()]
    public string age {
        get {
            return this.ageField;
        }
        set {
            this.ageField = value;
        }
    }
}
Vous aimez nos tutoriels ? Abonnez-vous à DelftStack sur YouTube pour nous aider à créer davantage de tutoriels vidéo de haute qualité. Abonnez-vous
Auteur: Abdullahi Salawudeen
Abdullahi Salawudeen avatar Abdullahi Salawudeen avatar

Abdullahi is a full-stack developer and technical writer with over 5 years of experience designing and implementing enterprise applications. He loves taking on new challenges and believes conceptual programming theories should be implemented in reality.

LinkedIn GitHub

Article connexe - Csharp Object