Deserializar XML a objeto en C#

  2. HowTo
  3. C# Howtos
  4. Deserializar XML a objeto en C#
Abdullahi Salawudeen 11 diciembre 2023
Csharp Csharp Object
  1. Use clases escritas manualmente para deserializar un archivo XML a un objeto C#
  2. Use la función Paste Special de Visual Studio para deserializar Xml a un objeto C#
  3. Utilice la herramienta XSD para deserializar XML a un objeto C#
Deserializar XML a objeto en C#

Este artículo demostrará la conversión o deserialización de archivos XML en el objeto C#.

Use clases escritas manualmente para deserializar un archivo XML a un objeto C#

  • C# está asociado con clases y objetos junto con atributos y métodos.
  • Los Objetos se representan con clases programáticamente, como John o James.
  • Los atributos son características de objetos como el color de un coche, año de producción, edad de una persona o color de un edificio.
  • XML es el formato estandarizado que permite analizar los datos XML independientemente del medio de transmisión del archivo XML.

Más discusión está disponible a través de esta referencia.

A continuación se muestra un ejemplo de código XML que se convertiría en un objeto 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>

Se crearía una clase con una estructura similar en C# para convertir la muestra de código 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; }
}

El paso final para convertir el objeto XML a C# es utilizar la función System.Xml.Serialization.XmlSerializer para serializar el objeto.

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

Use la función Paste Special de Visual Studio para deserializar Xml a un objeto C#

Este método requiere el uso de Microsoft Visual Studio 2012 y superior con .Net Framework 4.5 y superior. También se debe instalar la carga de trabajo de WCF para Visual Studio.

  • El contenido del documento XML debe copiarse en el portapapeles.
  • Agregar una nueva clase empty a la solución del proyecto.
  • Abre el nuevo archivo de clase.
  • Haga clic en el botón Editar en la barra de menú del IDE.
  • Seleccione Paste Special en el menú desplegable.
  • Haga clic en Pegar XML como clases.

Pegar XML como clases

Para usar la clase generada por Visual Studio, cree la clase 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());
    }
  }
}

Utilice la herramienta XSD para deserializar XML a un objeto C#

XSD se usa para generar automáticamente clases u objetos equivalentes al esquema definido en un archivo o documento XML.

XSD.exe normalmente se encuentra en la ruta: C:\Program Files (x86)\Microsoft SDKs\Windows\{version}\bin\NETFX {version} Tools\. Hay más información disponible en esta referencia.

Supongamos que el archivo XML se guarda en esta ruta: C:\X\test.XML.

A continuación se detallan los pasos a seguir para deserializar las clases XML a C# automáticamente:

  • Escriba Símbolo del sistema para desarrolladores en la barra de búsqueda y haga clic en él para abrirlo.
  • Escriba cd C:\X para navegar a la ruta del archivo XML.
  • Eliminar números de línea y cualquier carácter innecesario en el archivo XML.
  • Escriba xsd test.XML para crear un archivo XSD equivalente a partir de test.XML.
  • Se crea un archivo test.XSD en la misma ruta de archivo.
  • Escriba XSD /c test.XSD para crear las clases C# equivalentes al archivo XML.
  • Se crea un archivo test.cs, una clase C# con un esquema exacto del archivo XML.

Producción :

//------------------------------------------------------------------------------
// <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;
        }
    }
}
Autor: 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

Artículo relacionado - Csharp Object