Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Clase XmlDocument

 

Representa un documento XML. Puede usar esta clase para cargar, validar, editar, agregar y posicionar el código XML en un documento.

Espacio de nombres:   System.Xml
Ensamblado:  System.Xml (en System.Xml.dll)


public class XmlDocument : XmlNode

NombreDescripción
System_CAPS_pubmethodXmlDocument()

Inicializa una nueva instancia de la clase XmlDocument.

System_CAPS_protmethodXmlDocument(XmlImplementation)

Inicializa una nueva instancia de la clase XmlDocument con el objeto XmlImplementation especificado.

System_CAPS_pubmethodXmlDocument(XmlNameTable)

Inicializa una nueva instancia de la clase XmlDocument con el objeto XmlNameTable especificado.

NombreDescripción
System_CAPS_pubpropertyAttributes

Obtiene un XmlAttributeCollection que contiene los atributos de este nodo.(Heredado de XmlNode).

System_CAPS_pubpropertyBaseURI

Obtiene el identificador URI base del nodo actual.(Invalida XmlNode.BaseURI).

System_CAPS_pubpropertyChildNodes

Obtiene todos los nodos secundarios del nodo.(Heredado de XmlNode).

System_CAPS_pubpropertyDocumentElement

Obtiene el XmlElement raíz del documento.

System_CAPS_pubpropertyDocumentType

Obtiene el nodo que contiene la declaración DOCTYPE.

System_CAPS_pubpropertyFirstChild

Obtiene el primer nodo secundario del nodo.(Heredado de XmlNode).

System_CAPS_pubpropertyHasChildNodes

Obtiene un valor que indica si este nodo tiene nodos secundarios.(Heredado de XmlNode).

System_CAPS_pubpropertyImplementation

Obtiene el objeto XmlImplementation del documento actual.

System_CAPS_pubpropertyInnerText

Produce una InvalidOperationException en todos los casos.(Invalida XmlNode.InnerText).

System_CAPS_pubpropertyInnerXml

Obtiene o establece el marcado que representa los nodos secundarios del nodo actual.(Invalida XmlNode.InnerXml).

System_CAPS_pubpropertyIsReadOnly

Obtiene un valor que indica si el nodo actual es de solo lectura.(Invalida XmlNode.IsReadOnly).

System_CAPS_pubpropertyItem[String]

Obtiene el primer elemento secundario con el parámetro Name.(Heredado de XmlNode).

System_CAPS_pubpropertyItem[String, String]

Obtiene el primer elemento secundario con el parámetro LocalName y NamespaceURI.(Heredado de XmlNode).

System_CAPS_pubpropertyLastChild

Obtiene el último nodo secundario del nodo.(Heredado de XmlNode).

System_CAPS_pubpropertyLocalName

Obtiene el nombre local del nodo.(Invalida XmlNode.LocalName).

System_CAPS_pubpropertyName

Obtiene el nombre completo del nodo.(Invalida XmlNode.Name).

System_CAPS_pubpropertyNamespaceURI

Obtiene el identificador URI de espacio de nombres de este nodo.(Heredado de XmlNode).

System_CAPS_pubpropertyNameTable

Obtiene el XmlNameTable asociado a esta implementación.

System_CAPS_pubpropertyNextSibling

Obtiene el nodo inmediatamente siguiente a éste.(Heredado de XmlNode).

System_CAPS_pubpropertyNodeType

Obtiene el tipo del nodo actual.(Invalida XmlNode.NodeType).

System_CAPS_pubpropertyOuterXml

Obtiene el marcado que contiene este nodo y todos sus nodos secundarios.(Heredado de XmlNode).

System_CAPS_pubpropertyOwnerDocument

Obtiene el XmlDocument al que pertenece el nodo actual.(Invalida XmlNode.OwnerDocument).

System_CAPS_pubpropertyParentNode

Obtiene el nodo primario de este nodo, en los nodos que pueden tener nodos primarios.(Invalida XmlNode.ParentNode).

System_CAPS_pubpropertyPrefix

Obtiene o establece el prefijo de espacio de nombres de este nodo.(Heredado de XmlNode).

System_CAPS_pubpropertyPreserveWhitespace

Obtiene o establece un valor que indica si se va a conservar el espacio en blanco del contenido del elemento.

System_CAPS_pubpropertyPreviousSibling

Obtiene el nodo inmediatamente anterior a éste.(Heredado de XmlNode).

System_CAPS_pubpropertyPreviousText

Obtiene el nodo de texto inmediatamente anterior a este.(Heredado de XmlNode).

System_CAPS_pubpropertySchemaInfo

Devuelve el conjunto de información posterior a la validación del esquema (PSVI, Post-Schema-Validation-Infoset) del nodo.(Invalida XmlNode.SchemaInfo).

System_CAPS_pubpropertySchemas

Obtiene o establece el objeto XmlSchemaSet asociado a este objeto XmlDocument.

System_CAPS_pubpropertyValue

Obtiene o establece el valor del nodo.(Heredado de XmlNode).

System_CAPS_pubpropertyXmlResolver

Establece el objeto XmlResolver para usarlo en la resolución de recursos externos.

NombreDescripción
System_CAPS_pubmethodAppendChild(XmlNode)

Agrega el nodo especificado al final de la lista de nodos secundarios de este nodo.(Heredado de XmlNode).

System_CAPS_pubmethodClone()

Crea un duplicado de este nodo.(Heredado de XmlNode).

System_CAPS_pubmethodCloneNode(Boolean)

Crea un duplicado de este nodo.(Invalida XmlNode.CloneNode(Boolean)).

System_CAPS_pubmethodCreateAttribute(String)

Crea un objeto XmlAttribute con el Name especificado.

System_CAPS_pubmethodCreateAttribute(String, String)

Crea un XmlAttribute con el nombre completo especificados y el NamespaceURI.

System_CAPS_pubmethodCreateAttribute(String, String, String)

Crea un XmlAttribute con los Prefix, LocalName y NamespaceURI especificados.

System_CAPS_pubmethodCreateCDataSection(String)

Crea un XmlCDataSection que contiene los datos especificados.

System_CAPS_pubmethodCreateComment(String)

Crea un XmlComment que contiene los datos especificados.

System_CAPS_protmethodCreateDefaultAttribute(String, String, String)

Crea un atributo predeterminado con el prefijo, el nombre local y el identificador URI de espacio de nombres especificados.

System_CAPS_pubmethodCreateDocumentFragment()

Crea una interfaz XmlDocumentFragment.

System_CAPS_pubmethodCreateDocumentType(String, String, String, String)

Devuelve un nuevo objeto XmlDocumentType.

System_CAPS_pubmethodCreateElement(String)

Crea un elemento con el nombre especificado.

System_CAPS_pubmethodCreateElement(String, String)

Crea un XmlElement con el nombre completo y el NamespaceURI.

System_CAPS_pubmethodCreateElement(String, String, String)

Crea un elemento con los Prefix, LocalName y NamespaceURI especificados.

System_CAPS_pubmethodCreateEntityReference(String)

Crea un objeto XmlEntityReference con el nombre especificado.

System_CAPS_pubmethodCreateNavigator()

Crea un nuevo objeto XPathNavigator para navegar por este documento.(Invalida XmlNode.CreateNavigator()).

System_CAPS_protmethodCreateNavigator(XmlNode)

Crea un objeto XPathNavigator para navegar por este documento colocado en XmlNode especificado.

System_CAPS_pubmethodCreateNode(String, String, String)

Crea un XmlNode con el tipo de nodo especificado, Name y NamespaceURI.

System_CAPS_pubmethodCreateNode(XmlNodeType, String, String)

Crea un XmlNode con los XmlNodeType, Name y NamespaceURI especificados.

System_CAPS_pubmethodCreateNode(XmlNodeType, String, String, String)

Crea un XmlNode con los XmlNodeType, Prefix, Name y NamespaceURI especificados.

System_CAPS_pubmethodCreateProcessingInstruction(String, String)

Crea un XmlProcessingInstruction con el nombre y los datos especificados.

System_CAPS_pubmethodCreateSignificantWhitespace(String)
System_CAPS_pubmethodCreateTextNode(String)

Crea un objeto XmlTextcon el texto especificado.

System_CAPS_pubmethodCreateWhitespace(String)

Crea un nodo XmlWhitespace.

System_CAPS_pubmethodCreateXmlDeclaration(String, String, String)

Crea un nodo XmlDeclaration con los valores especificados.

System_CAPS_pubmethodEquals(Object)

Determina si el objeto especificado es igual al objeto actual.(Heredado de Object).

System_CAPS_protmethodFinalize()

Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por el recolector de basura. (Heredado de Object).

System_CAPS_pubmethodGetElementById(String)

Obtiene el XmlElement con el identificador especificado.

System_CAPS_pubmethodGetElementsByTagName(String)

Devuelve un objeto XmlNodeList que contiene una lista de todos los elementos descendientes que coinciden con el Name especificado.

System_CAPS_pubmethodGetElementsByTagName(String, String)

Devuelve un objeto XmlNodeList que contiene una lista de todos los elementos descendientes que coinciden con el LocalName y NamespaceURI especificados.

System_CAPS_pubmethodGetEnumerator()

Obtiene un enumerador que recorre en iteración los nodos secundarios del nodo actual.(Heredado de XmlNode).

System_CAPS_pubmethodGetHashCode()

Sirve como la función hash predeterminada.(Heredado de Object).

System_CAPS_pubmethodGetNamespaceOfPrefix(String)

Busca el más cercano xmlns declaración del prefijo especificado que está en el ámbito del nodo actual y devuelve el URI de espacio de nombres en la declaración.(Heredado de XmlNode).

System_CAPS_pubmethodGetPrefixOfNamespace(String)

Busca el más cercano xmlns declaración URI que está en el ámbito del nodo actual y devuelve el prefijo definido en la declaración de espacio de nombres especificado.(Heredado de XmlNode).

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object).

System_CAPS_pubmethodImportNode(XmlNode, Boolean)

Importa un nodo de otro documento al documento actual.

System_CAPS_pubmethodInsertAfter(XmlNode, XmlNode)

Inserta el nodo especificado inmediatamente detrás del nodo de referencia igualmente especificado.(Heredado de XmlNode).

System_CAPS_pubmethodInsertBefore(XmlNode, XmlNode)

Inserta el nodo especificado inmediatamente antes del nodo de referencia igualmente especificado.(Heredado de XmlNode).

System_CAPS_pubmethodLoad(Stream)

Carga el documento XML desde el flujo especificado.

System_CAPS_pubmethodLoad(String)

Carga el documento XML desde la dirección URL especificada.

System_CAPS_pubmethodLoad(TextReader)

Carga el documento XML desde el TextReader especificado.

System_CAPS_pubmethodLoad(XmlReader)

Carga el documento XML desde el XmlReader especificado.

System_CAPS_pubmethodLoadXml(String)

Carga el documento XML desde la cadena especificada.

System_CAPS_protmethodMemberwiseClone()

Crea una copia superficial del Object actual.(Heredado de Object).

System_CAPS_pubmethodNormalize()

Hace que todos los nodos XmlText de toda la profundidad del subárbol situado bajo XmlNode aparezcan de forma "normal", de modo que solo el marcado (es decir, las etiquetas, comentarios, instrucciones de procesamiento, secciones CDATA y referencias a entidades) separa los nodos XmlText, es decir, no hay nodos XmlText adyacentes.(Heredado de XmlNode).

System_CAPS_pubmethodPrependChild(XmlNode)

Agrega el nodo especificado al principio de la lista de nodos secundarios de este nodo.(Heredado de XmlNode).

System_CAPS_pubmethodReadNode(XmlReader)

Crea un objeto XmlNode tomando como base la información de XmlReader. El lector debe estar situado en un nodo o en un atributo.

System_CAPS_pubmethodRemoveAll()

Quita todos los atributos y nodos secundarios del nodo actual.(Heredado de XmlNode).

System_CAPS_pubmethodRemoveChild(XmlNode)

Quita el nodo secundario especificado.(Heredado de XmlNode).

System_CAPS_pubmethodReplaceChild(XmlNode, XmlNode)

Reemplaza el nodo secundario oldChild con newChild nodo.(Heredado de XmlNode).

System_CAPS_pubmethodSave(Stream)

Guarda el documento XML en el flujo especificado.

System_CAPS_pubmethodSave(String)

Guarda el documento XML en el archivo especificado. Si existe el archivo especificado, este método lo sobrescribe.

System_CAPS_pubmethodSave(TextWriter)

Guarda el documento XML en el TextWriter especificado.

System_CAPS_pubmethodSave(XmlWriter)

Guarda el documento XML en el XmlWriter especificado.

System_CAPS_pubmethodSelectNodes(String)

Selecciona una lista de nodos que coinciden con la expresión XPath.(Heredado de XmlNode).

System_CAPS_pubmethodSelectNodes(String, XmlNamespaceManager)

Selecciona una lista de nodos que coinciden con la expresión XPath. Los prefijos encontrados en la expresión XPath se resuelven utilizando proporcionado XmlNamespaceManager.(Heredado de XmlNode).

System_CAPS_pubmethodSelectSingleNode(String)

Selecciona el primer XmlNode que coincide con la expresión XPath.(Heredado de XmlNode).

System_CAPS_pubmethodSelectSingleNode(String, XmlNamespaceManager)

Selecciona el primer XmlNode que coincide con la expresión XPath. Los prefijos encontrados en la expresión XPath se resuelven utilizando proporcionado XmlNamespaceManager.(Heredado de XmlNode).

System_CAPS_pubmethodSupports(String, String)

Comprueba si la implementación de DOM incluye una característica específica.(Heredado de XmlNode).

System_CAPS_pubmethodToString()

Devuelve una cadena que representa al objeto actual. (Heredado de Object).

System_CAPS_pubmethodValidate(ValidationEventHandler)

Valida el objeto XmlDocument según los esquemas del lenguaje de definición de esquemas XML (XSD) de la propiedad Schemas.

System_CAPS_pubmethodValidate(ValidationEventHandler, XmlNode)

Valida el objeto XmlNode especificado según los esquemas del lenguaje de definición de esquemas XML (XSD) de la propiedad Schemas.

System_CAPS_pubmethodWriteContentTo(XmlWriter)

Guarda todos los nodos secundarios del nodo XmlDocument en el XmlWriter especificado.(Invalida XmlNode.WriteContentTo(XmlWriter)).

System_CAPS_pubmethodWriteTo(XmlWriter)

Guarda el nodo XmlDocument en el XmlWriter especificado.(Invalida XmlNode.WriteTo(XmlWriter)).

NombreDescripción
System_CAPS_pubeventNodeChanged

Se produce cuando el Value de un nodo que pertenece a este documento se modifica.

System_CAPS_pubeventNodeChanging

Se produce cuando el Value de un nodo que pertenece a este documento se va a modificar.

System_CAPS_pubeventNodeInserted

Se produce cuando un nodo que pertenece a este documento se ha insertado en otro nodo.

System_CAPS_pubeventNodeInserting

Se produce cuando un nodo que pertenece a este documento se va a insertar en otro nodo.

System_CAPS_pubeventNodeRemoved

Se produce cuando un nodo que pertenece a este documento se ha quitado de su nodo primario.

System_CAPS_pubeventNodeRemoving

Se produce cuando un nodo que pertenece a este documento se va a quitar del documento.

NombreDescripción
System_CAPS_pubinterfaceSystem_CAPS_privmethodIEnumerable.GetEnumerator()

Para una descripción de este miembro, vea XmlNode.GetEnumerator.(Heredado de XmlNode).

System_CAPS_pubinterfaceSystem_CAPS_privmethodICloneable.Clone()

Para una descripción de este miembro, vea XmlNode.Clone.(Heredado de XmlNode).

NombreDescripción
System_CAPS_pubmethodAsParallel()

Sobrecargado. Habilita la paralelización de una consulta.(Definido por ParallelEnumerable).

System_CAPS_pubmethodAsQueryable()

Sobrecargado. Convierte un IEnumerable para un IQueryable.(Definido por Queryable).

System_CAPS_pubmethodCast<TResult>()

Convierte los elementos de un IEnumerable al tipo especificado.(Definido por Enumerable).

System_CAPS_pubmethodOfType<TResult>()

Filtra los elementos de un IEnumerable basado en un tipo especificado.(Definido por Enumerable).


La XmlDocument clase es una representación en memoria de un documento XML. Implementa el W3C Modelo de objetos de documento XML (DOM) principal del nivel 1 y nivel 2 de DOM de núcleo.

DOM es el acrónimo modelo de objetos de documento. Para obtener más información, consulte Modelo de objetos de documento XML (DOM).

Puede cargar XML en el DOM utilizando el XmlDocument (clase) y, a continuación, mediante programación leer, modificar y quitar XML en el documento.

Si quieres de abre la XmlDocument clase y cómo se implementa, vea el Reference Source.

Comience con un documento XML como esta. Es tan solo unos libros en una colección. Pero contiene las acciones básicas que se encuentran en cualquier documento XML; un espacio de nombres, los elementos que representan los datos y atributos que describen los datos.

<?xml version="1.0" encoding="utf-8"?>
<books xmlns="http://www.contoso.com/books">
  <book genre="novel" ISBN="1-861001-57-8" publicationdate="1823-01-28">
    <title>Pride And Prejudice</title>
    <price>24.95</price>
  </book>
  <book genre="novel" ISBN="1-861002-30-1" publicationdate="1985-01-01">
    <title>The Handmaid's Tale</title>
    <price>29.95</price>
  </book>
  <book genre="novel" ISBN="1-861001-45-3" publicationdate="1811-01-01">
    <title>Sense and Sensibility</title>
    <price>19.95</price>
  </book>
</books>

A continuación, cargar estos datos en el DOM para que puede trabajar con ellos en memoria. La manera más popular de hacerlo es hacer referencia a un archivo en el equipo local o en una red.

En este ejemplo se carga XML desde un archivo. Si el archivo no existe, simplemente genera algunos datos XML y se carga.

XmlDocument doc = new XmlDocument();
doc.PreserveWhitespace = true;
try { doc.Load("booksData.xml"); }
catch (System.IO.FileNotFoundException)
{
    doc.LoadXml("<?xml version=\"1.0\"?> \n" +
    "<books xmlns=\"http://www.contoso.com/books\"> \n" +
    "  <book genre=\"novel\" ISBN=\"1-861001-57-8\" publicationdate=\"1823-01-28\"> \n" +
    "    <title>Pride And Prejudice</title> \n" +
    "    <price>24.95</price> \n" +
    "  </book> \n" +
    "  <book genre=\"novel\" ISBN=\"1-861002-30-1\" publicationdate=\"1985-01-01\"> \n" +
    "    <title>The Handmaid's Tale</title> \n" +
    "    <price>29.95</price> \n" +
    "  </book> \n" +
    "</books>");             
}

Ejemplo completo:Manipulate XML in-Memory by using the XmlDocument class and other related types

Más información:Lectura de un documento XML en el DOM

Comience con un esquema XML como este. Este esquema define los tipos de datos en el archivo XML y los atributos que son necesarios.

<?xml version="1.0" encoding="utf-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
  attributeFormDefault="unqualified" 
  elementFormDefault="qualified"
  targetNamespace="http://www.contoso.com/books"> 
  <xs:element name="books">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" name="book">
          <xs:complexType>
            <xs:sequence>
              <xs:element name="title" type="xs:string" />
              <xs:element name="price" type="xs:decimal" />
            </xs:sequence>
            <xs:attribute name="genre" type="xs:string" use="required" />
            <xs:attribute name="ISBN" type="xs:string" use="required" />
            <xs:attribute name="publicationdate" type="xs:date" use="required" />
          </xs:complexType>
        </xs:element>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>

Crear un objeto XmlReader mediante el esquema y, a continuación, cargar ese objeto en el DOM. Crear un controlador de eventos que se ejecuta cuando el código intenta modificar el archivo XML de maneras que infringen las reglas del esquema.

Estos bloques de código muestran métodos auxiliares que hacer todo esto.


//************************************************************************************
//
//  Associate the schema with XML. Then, load the XML and validate it against
//  the schema.
//
//************************************************************************************
public XmlDocument LoadDocumentWithSchemaValidation(bool generateXML, bool generateSchema)
{
    XmlReader reader;

    XmlReaderSettings settings = new XmlReaderSettings();

    // Helper method to retrieve schema.
    XmlSchema schema = getSchema(generateSchema);

    if (schema == null)
    {
        return null;
    }

    settings.Schemas.Add(schema);

    settings.ValidationEventHandler += settings_ValidationEventHandler;
    settings.ValidationFlags =
        settings.ValidationFlags | XmlSchemaValidationFlags.ReportValidationWarnings;
    settings.ValidationType = ValidationType.Schema;

    try
    {
        reader = XmlReader.Create("booksData.xml", settings);
    }
    catch (System.IO.FileNotFoundException)
    {
        if (generateXML)
        {
            string xml = generateXMLString();
            byte[] byteArray = Encoding.UTF8.GetBytes(xml);
            MemoryStream stream = new MemoryStream(byteArray);
            reader = XmlReader.Create(stream, settings);
        }
        else
        {
            return null;
        }

    }

    XmlDocument doc = new XmlDocument();
    doc.PreserveWhitespace = true;
    doc.Load(reader);
    reader.Close();

    return doc;
}

//************************************************************************************
//
//  Helper method that generates an XML Schema.
//
//************************************************************************************
private string generateXMLSchema()
{
    string xmlSchema =
        "<?xml version=\"1.0\" encoding=\"utf-8\"?> " +
        "<xs:schema attributeFormDefault=\"unqualified\" " +
        "elementFormDefault=\"qualified\" targetNamespace=\"http://www.contoso.com/books\" " +
        "xmlns:xs=\"http://www.w3.org/2001/XMLSchema\"> " +
        "<xs:element name=\"books\"> " +
        "<xs:complexType> " +
        "<xs:sequence> " +
        "<xs:element maxOccurs=\"unbounded\" name=\"book\"> " +
        "<xs:complexType> " +
        "<xs:sequence> " +
        "<xs:element name=\"title\" type=\"xs:string\" /> " +
        "<xs:element name=\"price\" type=\"xs:decimal\" /> " +
        "</xs:sequence> " +
        "<xs:attribute name=\"genre\" type=\"xs:string\" use=\"required\" /> " +
        "<xs:attribute name=\"publicationdate\" type=\"xs:date\" use=\"required\" /> " +
        "<xs:attribute name=\"ISBN\" type=\"xs:string\" use=\"required\" /> " +
        "</xs:complexType> " +
        "</xs:element> " +
        "</xs:sequence> " +
        "</xs:complexType> " +
        "</xs:element> " +
        "</xs:schema> ";
    return xmlSchema;
}

//************************************************************************************
//
//  Helper method that gets a schema
//
//************************************************************************************
private XmlSchema getSchema(bool generateSchema)
{
    XmlSchemaSet xs = new XmlSchemaSet();
    XmlSchema schema;
    try
    {
        schema = xs.Add("http://www.contoso.com/books", "booksData.xsd");
    }
    catch (System.IO.FileNotFoundException)
    {
        if (generateSchema)
        {
            string xmlSchemaString = generateXMLSchema();
            byte[] byteArray = Encoding.UTF8.GetBytes(xmlSchemaString);
            MemoryStream stream = new MemoryStream(byteArray);
            XmlReader reader = XmlReader.Create(stream);
            schema = xs.Add("http://www.contoso.com/books", reader);
        }
        else
        {
            return null;
        }

    }
    return schema;
}

//************************************************************************************
//
//  Helper method to validate the XML against the schema.
//
//************************************************************************************
private void validateXML(bool generateSchema, XmlDocument doc)
{
    if (doc.Schemas.Count == 0)
    {
        // Helper method to retrieve schema.
        XmlSchema schema = getSchema(generateSchema);
        doc.Schemas.Add(schema);
    }

    // Use an event handler to validate the XML node against the schema.
    doc.Validate(settings_ValidationEventHandler);

}

//************************************************************************************
//
//  Event handler that is raised when XML doesn't validate against the schema.
//
//************************************************************************************
void settings_ValidationEventHandler(object sender,
    System.Xml.Schema.ValidationEventArgs e)
{
    if (e.Severity == XmlSeverityType.Warning)
    {
        System.Windows.Forms.MessageBox.Show
            ("The following validation warning occurred: " + e.Message);
    }
    else if (e.Severity == XmlSeverityType.Error)
    {
        System.Windows.Forms.MessageBox.Show
            ("The following critical validation errors occurred: " + e.Message);
        Type objectType = sender.GetType();
    }

}

Ejemplo completo:Manipulate XML in-Memory by using the XmlDocument class and other related types

Más información:Validación de un documento XML en el DOM

Puede utilizar propiedades para desplazarse por un documento XML. Pero antes de utilizar cualquiera de ellos, vamos a repasar rápidamente una serie de términos. El documento se compone de nodos. Cada nodo tiene como único primario nodo directamente encima de él. El único nodo que no tiene un nodo primario es la raíz del documento, ya que es el nodo de nivel superior. La mayoría de los nodos puede tener secundarios nodos, que son nodos inmediatamente debajo de ellos. Los nodos que estén en el mismo nivel son elementos del mismo nivel.

Los ejemplos siguientes muestran cómo obtener el nodo raíz, ir al primer nodo secundario del nodo raíz, tener acceso a cualquiera de sus nodos secundarios, para que reciba el nodo primario y, a continuación, navegue a través de los nodos del mismo nivel.

Comience con el nodo raíz

Este ejemplo obtiene el nodo raíz y, a continuación, utiliza ese nodo para generar el contenido del documento en la consola.

using System;
using System.IO;
using System.Xml;

public class Sample
{
  public static void Main()
  {
    //Create the XmlDocument.
    XmlDocument doc = new XmlDocument();
    doc.LoadXml("<?xml version='1.0' ?>" +
                "<book genre='novel' ISBN='1-861001-57-5'>" +
                "<title>Pride And Prejudice</title>" +
                "</book>");

    //Display the document element.
    Console.WriteLine(doc.DocumentElement.OuterXml);
 }
}

Obtener los nodos secundarios

En este ejemplo se salta hasta el primer nodo secundario del nodo raíz y, a continuación, recorre en iteración los nodos secundarios de ese nodo si existe alguna.

using System;
using System.IO;
using System.Xml;

public class Sample {

  public static void Main() {

    XmlDocument doc = new XmlDocument();
    doc.LoadXml("<book ISBN='1-861001-57-5'>" +
                "<title>Pride And Prejudice</title>" +
                "<price>19.95</price>" +
                "</book>");

    XmlNode root = doc.FirstChild;

    //Display the contents of the child nodes.
    if (root.HasChildNodes)
    {
      for (int i=0; i<root.ChildNodes.Count; i++)
      {
        Console.WriteLine(root.ChildNodes[i].InnerText);
      }
    }
  }
}

Volver al nodo principal

Utilice la propiedad ParentNode.

Consulte en el último nodo secundario

En este ejemplo se escribe el precio de un libro en la consola (que es el último nodo secundario de un nodo de libro).

using System;
using System.IO;
using System.Xml;

public class Sample {

  public static void Main() {

    XmlDocument doc = new XmlDocument();
    doc.LoadXml("<book ISBN='1-861001-57-5'>" +
                "<title>Pride And Prejudice</title>" +
                "<price>19.95</price>" +
                "</book>");

    XmlNode root = doc.FirstChild;

    Console.WriteLine("Display the price element...");
    Console.WriteLine(root.LastChild.OuterXml);
  }
}

Desplazarse hacia delante a través de los elementos del mismo nivel

En este ejemplo se mueve hacia delante de un libro a otro libro. Nodos de libro están relacionados entre sí.

using System;
using System.Xml;

public class Sample {

  public static void Main() {

      XmlDocument doc = new XmlDocument();
      doc.Load("books.xml");

      XmlNode currNode = doc.DocumentElement.FirstChild;
      Console.WriteLine("First book...");
      Console.WriteLine(currNode.OuterXml);

      XmlNode nextNode = currNode.NextSibling;
      Console.WriteLine("\r\nSecond book...");
      Console.WriteLine(nextNode.OuterXml); 

  }
}

Navegar hacia atrás a través de los elementos del mismo nivel

Este ejemplo se mueve hacia atrás desde un libro a libro.

using System;
using System.Xml;

public class Sample {

  public static void Main() {

      XmlDocument doc = new XmlDocument();
      doc.Load("books.xml");

      XmlNode lastNode = doc.DocumentElement.LastChild;
      Console.WriteLine("Last book...");
      Console.WriteLine(lastNode.OuterXml);

      XmlNode prevNode = lastNode.PreviousSibling;
      Console.WriteLine("\r\nPrevious book...");
      Console.WriteLine(prevNode.OuterXml);  
  }
}

La manera más popular para buscar uno o varios nodos de datos consiste en utilizar una cadena de consulta de XPath, pero también hay métodos que no requieren una.

Obtener un único nodo

En este ejemplo se busca un libro mediante el número ISBN.

public XmlNode GetBook(string uniqueAttribute, XmlDocument doc)
{
    XmlNamespaceManager nsmgr = new XmlNamespaceManager(doc.NameTable);
    nsmgr.AddNamespace("bk", "http://www.contoso.com/books");
    string xPathString = "//bk:books/bk:book[@ISBN='" + uniqueAttribute + "']";
    XmlNode xmlNode = doc.DocumentElement.SelectSingleNode(xPathString, nsmgr);
   return xmlNode;
}

La cadena que se usa en este ejemplo es una consulta Xpath. Puede encontrar más ejemplos de esto aquí: XPath examples.

También puede usar el GetElementById para recuperar nodos. Para utilizar este enfoque, tendrá que definir identificadores en las declaraciones de definición de tipo de documento del archivo XML.

Una vez que consiga un nodo, obtendrá el valor de atributos o nodos secundarios. Este ejemplo hace con un nodo de libro.

public void GetBookInformation(ref string title, ref string ISBN, ref string publicationDate,
    ref string price, ref string genre, XmlNode book)
{
    XmlElement bookElement = (XmlElement)book;

    // Get the attributes of a book.        
    XmlAttribute attr = bookElement.GetAttributeNode("ISBN");
    ISBN = attr.InnerXml;

    attr = bookElement.GetAttributeNode("genre");
    genre = attr.InnerXml;

    attr = bookElement.GetAttributeNode("publicationdate");
    publicationDate = attr.InnerXml;

    // Get the values of child elements of a book.
    title = bookElement["title"].InnerText;
    price = bookElement["price"].InnerText;
}

Obtiene una colección de nodos

Este ejemplo selecciona todos los libros, donde es el nombre del autor última Austeny, a continuación, cambia el precio de esos libros.

using System;
using System.IO;
using System.Xml;

public class Sample {

  public static void Main() {

    XmlDocument doc = new XmlDocument();
    doc.Load("booksort.xml");

    XmlNodeList nodeList;
    XmlNode root = doc.DocumentElement;

    nodeList=root.SelectNodes("descendant::book[author/last-name='Austen']");

    //Change the price on the books.
    foreach (XmlNode book in nodeList)
    {
      book.LastChild.InnerText="15.95";
    }

    Console.WriteLine("Display the modified XML document....");
    doc.Save(Console.Out);

  }
}

También puede obtener una colección de nodos con el nombre del nodo. Por ejemplo, en este ejemplo se obtiene una colección de todos los títulos de libros.

using System;
using System.IO;
using System.Xml;

public class Sample
{
  public static void Main()
  {
    //Create the XmlDocument.
    XmlDocument doc = new XmlDocument();
    doc.Load("books.xml");

    //Display all the book titles.
    XmlNodeList elemList = doc.GetElementsByTagName("title");
    for (int i=0; i < elemList.Count; i++)
    {   
      Console.WriteLine(elemList[i].InnerXml);
    }  

  }
}

Ejemplo completo:Manipulate XML in-Memory by using the XmlDocument class and other related types

Más información:Selección de nodos con la navegación XPath

En este ejemplo se modifica un nodo de libro y sus atributos.

public void editBook(string title, string ISBN, string publicationDate,
    string genre, string price, XmlNode book, bool validateNode, bool generateSchema)
{

    XmlElement bookElement = (XmlElement)book;

    // Get the attributes of a book.        
    bookElement.SetAttribute("ISBN", ISBN);
    bookElement.SetAttribute("genre", genre);
    bookElement.SetAttribute("publicationdate", publicationDate);

    // Get the values of child elements of a book.
    bookElement["title"].InnerText = title;
    bookElement["price"].InnerText = price;

    if (validateNode)
    {
        validateXML(generateSchema, bookElement.OwnerDocument);
    }
}

Más información:Modificación de nodos, contenido y valores en un documento XML

Ejemplo completo:Manipulate XML in-Memory by using the XmlDocument class and other related types

Para agregar un nodo, use la CreateElement método o la CreateNode método.

Para agregar un nodo de datos como un libro, use el CreateElement método.

Para cualquier otro tipo de nodo como un comentario, nodo de espacio en blanco o nodo CDATA, use la CreateNode método.

Este ejemplo crea un nodo de libro, agrega atributos a ese nodo y, a continuación, agrega ese nodo al documento.

public XmlElement AddNewBook(string genre, string ISBN, string misc, 
    string title, string price, XmlDocument doc)
{
    // Create a new book element.
    XmlElement bookElement = doc.CreateElement("book", "http://www.contoso.com/books");

    // Create attributes for book and append them to the book element.
    XmlAttribute attribute = doc.CreateAttribute("genre");
    attribute.Value = genre;
    bookElement.Attributes.Append(attribute);

    attribute = doc.CreateAttribute("ISBN");
    attribute.Value = ISBN;
    bookElement.Attributes.Append(attribute);

    attribute = doc.CreateAttribute("publicationdate");
    attribute.Value = misc;
    bookElement.Attributes.Append(attribute);

    // Create and append a child element for the title of the book.
    XmlElement titleElement = doc.CreateElement("title");
    titleElement.InnerText = title;
    bookElement.AppendChild(titleElement);

    // Introduce a newline character so that XML is nicely formatted.
    bookElement.InnerXml = 
        bookElement.InnerXml.Replace(titleElement.OuterXml, 
        "\n    " + titleElement.OuterXml + " \n    ");

    // Create and append a child element for the price of the book.
    XmlElement priceElement = doc.CreateElement("price");
    priceElement.InnerText= price;
    bookElement.AppendChild(priceElement);

    // Introduce a newline character so that XML is nicely formatted.
    bookElement.InnerXml =
        bookElement.InnerXml.Replace(priceElement.OuterXml, priceElement.OuterXml + "   \n  ");

    return bookElement;

}

Ejemplo completo:Manipulate XML in-Memory by using the XmlDocument class and other related types

Más información:Inserción de nodos en un documento XML

Para quitar un nodo, use la RemoveChild método.

En este ejemplo se quita un libro desde el documento y cualquier espacio en blanco que aparece justo antes del nodo de libro.

public void deleteBook(XmlNode book)
{
    XmlNode prevNode = book.PreviousSibling;

    book.OwnerDocument.DocumentElement.RemoveChild(book);


    if (prevNode.NodeType == XmlNodeType.Whitespace || 
        prevNode.NodeType == XmlNodeType.SignificantWhitespace)
    {
        prevNode.OwnerDocument.DocumentElement.RemoveChild(prevNode);
    }
}

Ejemplo completo:Manipulate XML in-Memory by using the XmlDocument class and other related types

Más información:Cómo quitar nodos, contenido y valores de un documento XML

Puede elegir dónde desea un nodo que aparezca en el documento mediante el uso de la InsertBefore y InsertAfter métodos.

Este ejemplo muestra dos métodos auxiliares. Uno de ellos mueve un nodo superior en una lista. El otro mueve un nodo inferior.

Estos métodos pudieron usarse en una aplicación que permite a los usuarios mover hacia arriba y hacia abajo los libros en una lista de libros. Cuando un usuario elige un libro y presiona un arriba o hacia abajo del botón, el código puede llamar a métodos como estos para colocar el nodo de libro correspondiente antes o después de otros nodos de libro.

//************************************************************************************
//
//  Summary: Move elements up in the XML.
//  
//
//************************************************************************************

public void MoveElementUp(XmlNode book)
{
    XmlNode previousNode = book.PreviousSibling;
    while (previousNode != null && (previousNode.NodeType != XmlNodeType.Element))
    {
        previousNode = previousNode.PreviousSibling;
    }
    if (previousNode != null)
    {
        XmlNode newLineNode = book.NextSibling;
        book.OwnerDocument.DocumentElement.RemoveChild(book);
        if (newLineNode.NodeType == XmlNodeType.Whitespace | 
            newLineNode.NodeType == XmlNodeType.SignificantWhitespace)
        {
            newLineNode.OwnerDocument.DocumentElement.RemoveChild(newLineNode);
        }
        InsertBookElement((XmlElement)book, Constants.positionAbove, 
            previousNode, false, false);
    }
}


//************************************************************************************
//
//  Summary: Move elements down in the XML.
//  
//
//************************************************************************************
public void MoveElementDown(XmlNode book)
{
    // Walk backwards until we find an element - ignore text nodes
    XmlNode NextNode = book.NextSibling;
    while (NextNode != null && (NextNode.NodeType != XmlNodeType.Element))
    {
        NextNode = NextNode.NextSibling;
    }
    if (NextNode != null)
    {
        XmlNode newLineNode = book.PreviousSibling;
        book.OwnerDocument.DocumentElement.RemoveChild(book);
        if (newLineNode.NodeType == XmlNodeType.Whitespace |
            newLineNode.NodeType == XmlNodeType.SignificantWhitespace)
        {
            newLineNode.OwnerDocument.DocumentElement.RemoveChild(newLineNode);
        }

        InsertBookElement((XmlElement)book, Constants.positionBelow, 
            NextNode, false, false);
    }

}

Ejemplo completo:Manipulate XML in-Memory by using the XmlDocument class and other related types

Plataforma universal de Windows
Disponible desde 10
.NET Framework
Disponible desde 1.1

Cualquier miembro ( Compartido en Visual Basic) estático público de este tipo es seguro para subprocesos. No se garantiza que los miembros de instancia sean seguros para subprocesos.

Volver al principio
Mostrar: