Cómo leer XML en C#

Como Leer Xml En C



El formato de datos ampliamente utilizado para compartir datos en Internet es XML, ya que los datos pueden almacenarse e intercambiarse entre sistemas de una manera flexible y fácil de usar. En C#, leer archivos XML es una tarea común y .NET Framework proporciona varias clases y métodos para analizar y leer archivos XML. Esta publicación repasará la utilización del marco .NET para leer XML en C#.

Leer XML en C#

Hay varias formas de leer un archivo XML en C# y cada método tiene sus ventajas y desventajas, y la elección depende de los requisitos del proyecto. A continuación se muestran algunas formas de leer un archivo XML en C#:

Aquí está el contenido del archivo XML que he creado y se usará para demostración en los próximos métodos:







< ?xml versión = '1.0' codificación = 'utf-8' ? >
< empleados >
  < empleado >
    < identificación > 1 identificación >
    < nombre > sam bosh nombre >
    < departamento > Marketing departamento >
    < salario > 50000 salario >
  empleado >
  < empleado >
    < identificación > 2 identificación >
    < nombre > fulano de tal nombre >
    < departamento > Finanzas departamento >
    < salario > 60000 salario >
  empleado >
  < empleado >
    < identificación > 3 identificación >
    < nombre > Jaime nombre >
    < departamento > Recursos humanos departamento >
    < salario > 70000 salario >
  empleado >
empleados >

1: Uso de documento Xml

Para leer un archivo XML en C#, puede usar la clase XmlDocument o la clase XDocument, las cuales forman parte del espacio de nombres System.Xml. La clase XmlDocument proporciona un enfoque DOM (Document Object Model) para leer XML, mientras que la clase XDocument proporciona un enfoque LINQ (Language-Integrated Query). Aquí hay un ejemplo que utiliza la clase XmlDocument para leer un archivo XML:



utilizando el sistema;
utilizando System.Xml;

programa de clase
{
vacío estático principal ( cadena [ ] argumentos )
    {
XmlDocument doc = nuevo XmlDocument ( ) ;
doc.Cargar ( 'empleados.xml' ) ;

Nodos XmlNodeList = doc.DocumentElement.SelectNodes ( '/empleados/empleado' ) ;

para cada ( nodo XmlNode en nodos )
        {
cadena identificación = node.SelectSingleNode ( 'identificación' ) .Texto Interior;
cadena nombre = nodo.SelectSingleNode ( 'nombre' ) .Texto Interior;
cadena departamento = nodo.SelectSingleNode ( 'departamento' ) .Texto Interior;
cadena salario = nodo.SelectSingleNode ( 'salario' ) .Texto Interior;
Consola.WriteLine ( 'ID: {0}, Nombre: {1}, Departamento: {2}, Salario: {3}' , identificación , nombre, departamento, salario ) ;
        }
    }
}

Este código usa la clase XmlDocument para cargar el archivo XML y el método SelectNodes para recuperar una lista de nodos de empleados. Luego, para cada nodo de empleado, utiliza el método SelectSingleNode para recuperar los valores de los nodos secundarios de id, nombre, departamento y salario y los muestra mediante Console.WriteLine:







2: Uso de XDocument

Alternativamente, también puede usar la clase XDocument para leer un archivo XML usando un enfoque LINQ, y a continuación se muestra el código que ilustra cómo hacerlo:

utilizando el sistema;

programa de clase
{
vacío estático principal ( cadena [ ] argumentos )
    {
XDocumento doc = XDocumento.Cargar ( 'empleados.xml' ) ;

para cada ( Elemento XElement en doc.descendientes ( 'empleado' ) )
        {
En t identificación = int.Analizar ( elemento.Elemento ( 'identificación' ) .Valor ) ;
cadena nombre = elemento.Elemento ( 'nombre' ) .Valor;
cadena departamento = elemento.Elemento ( 'departamento' ) .Valor;
salario int = int.Parse ( elemento.Elemento ( 'salario' ) .Valor ) ;
Consola.WriteLine ( $ 'ID: {id}, Nombre: {nombre}, Departamento: {departamento}, Salario: {salario}' ) ;
        }
    }
}

El archivo XML se carga en un objeto XDocument mediante el método XDocument.Load. A continuación, todos los elementos de 'empleado' del archivo XML se recuperan utilizando la técnica Descendientes. Para cada elemento, se accede a sus elementos secundarios mediante el método Element y sus valores se extraen mediante la propiedad Value. Finalmente, los datos extraídos se imprimen en la consola.



Tenga en cuenta que XDocument pertenece al espacio de nombres System.Xml.Linq, por lo que debe incluir la siguiente declaración de uso en la parte superior de su archivo C#

3: Uso de XmlReader

XmlReader es una forma rápida y eficiente de leer un archivo XML en C#. Lee el archivo secuencialmente, lo que significa que solo carga un nodo a la vez, lo que lo hace ideal para trabajar con archivos XML grandes que, de otro modo, serían difíciles de manejar en la memoria.

utilizando el sistema;
utilizando System.Xml;

programa de clase
{
vacío estático Principal ( cadena [ ] argumentos )
    {
usando ( Lector XmlReader = XmlReader.Create ( 'empleados.xml' ) )
        {
            mientras ( reader.Read ( ) )
            {
                si ( lector.NodeType == XmlNodeType.Element && reader.Name == 'empleado' )
                {
Consola.WriteLine ( 'IDENTIFICACIÓN: ' + lector.GetAttribute ( 'identificación' ) ) ;
lector.ReadToDescendant ( 'nombre' ) ;
Consola.WriteLine ( 'Nombre: ' + lector.ReadElementContentAsString ( ) ) ;
lector.ReadToNextSibling ( 'departamento' ) ;
Consola.WriteLine ( 'Departamento: ' + lector.ReadElementContentAsString ( ) ) ;
lector.ReadToNextSibling ( 'salario' ) ;
Consola.WriteLine ( 'Salario: ' + lector.ReadElementContentAsString ( ) ) ;
                }
            }
        }
    }
}

En este ejemplo, usamos XmlReader.Create un método para crear una instancia de XmlReader y pasar la ruta del archivo XML como parámetro. Luego usamos un ciclo while para leer el archivo XML nodo por nodo usando el método Read de XmlReader.

Dentro del ciclo, primero verificamos si el nodo actual es un elemento de empleado usando las propiedades NodeType y Name de XmlReader. Si es así, empleamos el método GetAttribute para recuperar el valor del atributo id.

A continuación, usamos el método ReadToDescendant para mover al lector al elemento de nombre dentro del elemento de empleado. A continuación, el valor del elemento de nombre se obtiene mediante la función ReadElementContentAsString.

De manera similar, usamos el método ReadToNextSibling para mover al lector al siguiente elemento hermano y obtener el valor de los elementos de departamento y salario.

Finalmente, usamos el uso de bloque para asegurarnos de que el objeto XmlReader se elimine correctamente después de que terminemos de leer el archivo XML:

4: XML a LINQ

Leer un archivo XML mediante LINQ to XML en C# es una forma eficaz de acceder y manipular datos XML. LINQ to XML es un componente de la tecnología LINQ que proporciona una API simple y eficiente para trabajar con datos XML.

utilizando el sistema;
utilizando System.Linq;
utilizando System.Xml.Linq;

programa de clase
{
vacío estático principal ( cadena [ ] argumentos )
    {
XDocumento doc = XDocumento.Cargar ( 'empleados.xml' ) ;

var empleados = de e en doc.descendientes ( 'empleado' )
                        seleccionar nuevo
                        {
Id = e.Elemento ( 'identificación' ) .Valor,
Nombre = e.Elemento ( 'nombre' ) .Valor,
Departamento = e.Elemento ( 'departamento' ) .Valor,
Salario = e.Elemento ( 'salario' ) .Valor
                        } ;
para cada ( empleado de var en empleados )
        {
Consola.WriteLine ( $ 'Id: {empleado.Id}, Nombre: {empleado.Nombre}, Departamento: {empleado.Departamento}, Salario: {empleado.Salario}' ) ;
        }
    }
}

En este código, primero cargamos el archivo XML usando el método XDocument.Load(). Luego, usamos LINQ to XML para consultar los datos XML y seleccionar los elementos de identificación, nombre, departamento y salario para cada elemento de empleado. Almacenamos estos datos en un tipo anónimo y luego recorremos los resultados para imprimir la información del empleado en la consola.

5: Uso de XPath

XPath es un lenguaje de consulta que se utiliza para navegar a través de un documento XML para localizar elementos, atributos y nodos específicos. Es una herramienta eficaz para la búsqueda y filtrado de información en un documento XML. En C#, podemos usar el lenguaje XPath para leer y extraer datos de archivos XML.

utilizando el sistema;
utilizando System.Xml.XPath;
utilizando System.Xml;

programa de clase
{
vacío estático principal ( cadena [ ] argumentos )
    {  
XmlDocument doc = nuevo XmlDocument ( ) ;
doc.Cargar ( 'empleados.xml' ) ;

        // Cree un XPathNavigator a partir del documento
XPathNavigator nav = doc.CreateNavigator ( ) ;

        // Compile la expresión XPath
XPathExpression expr = nav.Compilar ( '/empleados/empleado/nombre' ) ;

        // Evaluar la expresión e iterar a través de los resultados.
XPathNodeIterator iterador = nav.Select ( expr ) ;
        mientras ( iterador.MoveNext ( ) )
        {
Consola.WriteLine ( iterador.Valor.Actual ) ;
        }
    }
}

Este código carga el archivo 'employees.xml' mediante un XmlDocument, crea un XPathNavigator a partir del documento y compila una expresión XPath para seleccionar todos los elementos debajo de los elementos . Luego evalúa la expresión e itera a través de los resultados, imprimiendo el valor de cada elemento .

Nota: Usar XPath puede ser una forma poderosa y flexible de seleccionar elementos y atributos de un documento XML, pero también puede ser más complejo que algunos de los otros métodos que hemos discutido.

Conclusión

El uso de la clase XmlDocument proporciona capacidades completas de manipulación de DOM, pero puede ser más lento y consumir más memoria que los otros métodos. La clase XmlReader es una buena opción para leer archivos XML de gran tamaño, ya que proporciona un enfoque basado en secuencias rápido, de solo avance y no almacenado en caché. La clase XDocument proporciona una sintaxis más simple y concisa, pero puede que no sea tan eficaz como XmlReader. Además, los métodos LINQ to XML y XPath brindan poderosas capacidades de consulta para extraer datos específicos de un archivo XML.