Familiaridad con herramientas modernas para trabajar con XML. Creando un elemento XML con elementos secundarios. Accediendo a elementos secundarios
Trabajar con datos en formato XML en aplicaciones ASP.NET 2.0, el objeto XmlDataDocument y el control XML
Este módulo se centra en cómo trabajar con datos XML desde aplicaciones ASP.NET.
XML significa lenguaje de marcado extensible, aunque XML en sí no es un lenguaje. XML es un conjunto de reglas que se utilizan para crear sus propios lenguajes de marcado. Por ejemplo, imaginemos que tenemos los siguientes datos sobre un empleado:
Estos datos, por supuesto, se pueden presentar de cualquier forma: en forma de tabla en base de datos relacional datos, en forma tablas de excel o HTML, como una tabla en documento de palabra o en la forma documento de texto ASCII, como archivo *.csv, etc. Si los presentamos en el formato del lenguaje de marcado compatible con XML ABML (Lenguaje de marcado de libreta de direcciones) que inventamos, se verán así:
Un poco sobre cómo descifrar este código. Las dos primeras líneas son un prólogo (su uso es, en principio, opcional, pero muy recomendable). Línea
se denomina Declaración XML e indica que el archivo cumple con la especificación XML 1.0, adoptada como recomendación por el World Wide Web Consortium el 10 de febrero de 1998. Línea
se denomina Definición de tipo de documento y significa que la estructura del idioma al que corresponde este documento se describe en el archivo abml.dtd (también puede utilizar DTD internas cuando la descripción del idioma se encuentra directamente en el documento). Hoy en día, en lugar de DTD, el esquema XML se utiliza con más frecuencia para describir la estructura de los lenguajes compatibles con XML: son más fáciles de acceder y brindan más capacidades, en particular, al describir varios tipos de datos. La misma línea usando el esquema XML podría verse así:
dependiendo de dónde se encuentre el esquema en sí (la descripción de este lenguaje) en el archivo abml.xml o en el servidor web (almacenamiento de esquemas corporativos de Microsoft - BizTalk Server).
Un esquema XML de ejemplo para nuestro lenguaje podría verse así:
XML es un conjunto formalizado de reglas para "marcar" un documento, es decir, resaltar su estructura lógica. Lo que hay dentro de cualquier documento compatible con XML se puede dividir en dos categorías: marcado y contenido en sí. Toda la información de marcado debe comenzar con un carácter comercial (&) o un carácter de corchete angular izquierdo (<). В XML существует шесть типов информации разметки: элементы, атрибуты, комментарии, инструкции обработки, ссылки на сущности и разделы CDATA.
· Elementos(elementos) es el tipo más común de información de marcado. El elemento identifica un componente lógico de un documento. Un documento típico consta de etiquetas de apertura y cierre, que pueden rodear el contenido, otro elemento o ambos. Las etiquetas con nombres de elementos están entre corchetes angulares. Aquí hay un elemento de ejemplo:
· Atributos(atributos) constan de un par de nombre de atributo/valor de atributo y se aplican a elementos. Los atributos deben colocarse después del nombre del elemento en la etiqueta de apertura. Por ejemplo, los atributos son ancho y alto:
· Comentarios(comentarios) es cualquier texto que será ignorado por el procesador XML. Ejemplo:
· Instrucciones de procesamiento(instrucciones de procesamiento) se utilizan para pasar información a la aplicación que procesa el documento XML. La sintaxis de las instrucciones de procesamiento se ve así:
· Referencias de entidades Las referencias de entidades se utilizan para colocar caracteres reservados o palabras reservadas en un documento. Por ejemplo, necesitamos insertar un corchete angular izquierdo (<), которая является зарезервированным символом XML. Просто так вставить в текст документа мы ее не сможем: приложение, работающее с документом, решит, что она относится к разметке. Поэтому нам необходимо использовать сочетание символов <. lt означает menos que(menor que), y el signo comercial (&) y el punto y coma (;) resaltan una referencia de entidad.
· sección CDATA(sección CDATA) es un fragmento de texto que no se procesa como el resto del documento XML, sino que se pasa directamente a la aplicación. Esta herramienta puede resultar útil, por ejemplo, a la hora de pasar algún código a una aplicación.
Principios de sintaxis XML:
· Los documentos XML se componen de caracteres Unicode (Unicode es un conjunto de caracteres de 16 bits que permite mostrar documentos en cualquier idioma).
· XML distingue entre mayúsculas y minúsculas. Etiquetas Y Hay diferentes etiquetas en él.
· Los espacios en blanco son caracteres invisibles como el espacio (ASCII 32), la tabulación (ASCII 9), los retornos de carro (ASCII 13) y los avances de línea (ASCII 10). Los espacios en blanco se ignoran dentro de las etiquetas, pero se conservan en los datos de caracteres (es decir, entre las etiquetas de apertura y cierre). Los espacios en blanco en los datos de caracteres se pasan a la aplicación de procesamiento.
· Muchos componentes XML deben tener nombres (el ejemplo más obvio son elementos y atributos). Las reglas de nomenclatura XML son las siguientes: El nombre XML debe comenzar con una letra o un guión bajo, seguido de cualquier número de letras, números, guiones, guiones bajos o puntos, por ejemplo:
Mi_identificador_de_etiqueta_único-123 2_Este_nombre_es_incorrecto
· El nombre del componente XML no puede comenzar con caracteres xml (ya sean mayúsculas o minúsculas). Los creadores de las especificaciones reservan dichos nombres para fines oficiales.
· Los valores de caracteres deben estar entre comillas simples o dobles.
· En XML, se debe observar estrictamente el orden de anidamiento de las etiquetas.
· Cualquier etiqueta de apertura en XML debe tener una etiqueta de cierre correspondiente.
· Una etiqueta vacía en XML se escribe como una etiqueta de apertura, precedida por un corchete en ángulo recto con una barra diagonal (/).
· Sólo puede haber un elemento raíz en un documento XML.
¿Cuáles son las ventajas de almacenar datos en XML sobre los formatos binarios tradicionales? ¿Por qué la mayoría de los principales fabricantes de software están cambiando por completo a trabajar con datos en un formato compatible con XML (por ejemplo, Microsoft Office 2003) o planean hacerlo en un futuro próximo? La razón principal es que los datos XML son muy fáciles de transferir entre una amplia variedad de aplicaciones y muy fáciles de transformar. Puntos adicionales relacionados con los beneficios de XML:
- Formato de datos independiente: los datos en formato XML se pueden abrir en cualquier aplicación compatible con XML (más precisamente, compatible con un esquema específico). Ejemplo: en cualquier empresa, los documentos se almacenan en una variedad de formatos: formatos de diferentes versiones de Word, texto, HTML, PDF, etc. Debido a esto, surgen muchos problemas que pueden resolverse radicalmente con la ayuda de XML.
- El principio general es una fuente de datos (documento XML), muchas vistas. Esto se puede demostrar claramente usando el ejemplo de un sitio web al que se debe acceder desde diferentes navegadores y mediante WAP.
- Transferencia de datos mucho más sencilla “a través” de aplicaciones. Algunos ejemplos son el paso de documentos a través de una cadena de suministro o el paso de datos entre productos de software diferentes en una empresa (lo cual es necesario muy a menudo).
- Capacidades de búsqueda de datos mejoradas. En primer lugar, no es necesario acceder a documentos de diferentes formatos binarios y, en segundo lugar, la estructura jerárquica de los documentos XML facilita la búsqueda.
- Desarrollo de aplicaciones más sencillo: no es necesario implementar soporte para una gran cantidad de formatos de datos binarios diferentes en las aplicaciones.
- Los datos en formato de texto (XML - estándar Unicode) son más fáciles de almacenar que los binarios en varias plataformas y más seguros (en términos de ausencia de código binario malicioso) de transmitir a través de redes. Toda una dirección en el desarrollo de aplicaciones son los servicios web XML.
XML bien formado es código XML que cumple con los requisitos de sintaxis de ese lenguaje (por ejemplo, cada etiqueta de apertura tiene una etiqueta de cierre correspondiente). XML válido es válido en términos de la estructura lógica del lenguaje (por ejemplo, los elementos están anidados correctamente) tal como se define en el DTD o el esquema XML.
Un poco de terminología XML que se utilizará en este curso:
· XSD - Definición de esquema XML, una descripción de la estructura de un documento XML comúnmente utilizado en VS .NET. Normalmente se encuentra en archivos con la extensión *.xsd. Se utilizan etiquetas especiales dentro del esquema.
xmlns:od="urna:schemas-microsoft-com:officedata">
Para definir un elemento de cadena Apellido dentro de un esquema que puede aparecer 0 o más veces en un documento, puede, por ejemplo, utilizar la siguiente etiqueta:
tipo="cadena">
· para describir transformaciones de documentos compatibles con XML, se utilizan documentos en un lenguaje de programación especial XSLT (eXtensible Stylesheet Language Transform). Por supuesto, el lenguaje en sí también es compatible con XML. XSLT utiliza tres tipos de documentos:
o documento fuente. Este documento XML es "entrada" para la transformación. En nuestro caso, este podría ser un documento como este:
hoja de estilo xml tipo="texto/xsl" href=" Empleados1.xsl"?>
o Documento de hoja de estilo XSLT: un documento compatible con XML que describe las reglas para realizar transformaciones. En nuestro caso, un ejemplo de este documento podría ser así:
xmlns:xsl=" http://www.w3.org/1999/XSL/Transform"
versión=" 1.0 ">
o documento - el resultado de transformaciones. Por ejemplo, al aplicar nuestra transformación, el nombre del empleado se marcará en rojo y su puesto se marcará en azul.
· XPath es un lenguaje especial que se puede utilizar para navegar a través de un árbol de elementos XML. Cuando se utiliza el modelo de objetos XPath, un documento XML se representa como un árbol de nodos. La información está contenida en las propiedades de estos nodos.
· DOM (modelo de objetos de documento): representación de un árbol de documentos XML en RAM. DOM le permite navegar y editar un documento XML. Las propiedades, métodos y eventos DOM estándar se definen en un documento adoptado por el W3C. En ASP.NET, puede utilizar DOM para crear un documento XML y enviarlo al navegador del usuario. Otra opción es que un script de cliente cree un documento XML en el cliente utilizando el DOM y lo envíe al servidor web.
· XQuery es un lenguaje especializado para consultar información almacenada en documentos XML. XQuery se basa en gran medida en XPath.
Hay que decir que XML es un formato estándar para trabajar con datos en ADO.NET. Acerca del formato XML y cómo se puede utilizar con DataSet, a continuación.
Las posibilidades de utilizar XML cuando se trabaja con DataSet son las siguientes:
· Los conjuntos de datos pueden serializar datos en formato XML. El esquema del conjunto de datos (incluidas tablas, columnas, tipos de datos y restricciones) se define en un esquema XML (archivo .xsd).
· el intercambio de datos del DataSet con clientes remotos debe realizarse en formato XML;
· XML se puede utilizar para sincronizar y transformar datos en un conjunto de datos.
Un poco más sobre la interacción entre XML y DataSet:
· no sólo puedes crear un esquema XML basado en un conjunto de datos (como se mencionó anteriormente, esto se hace usando el método WriteXmlSchema), sino también viceversa: generar un conjunto de datos basado en la información de su esquema XML (para esto, usa el método ReadXmlSchema método). Es posible generar un conjunto de datos incluso sin un esquema, simplemente basándose en un documento XML. El método InferXmlSchema está destinado a este propósito.
· se proporciona un método para el objeto DataSet Leer XML, que le permite leer un documento de texto XML (flujo de datos de texto XML) en un conjunto de datos. Otro método Escribir XML, le permite guardar el contenido de un DataSet en un formato compatible con XML. Esta característica hace que sea muy fácil organizar el intercambio de datos entre diferentes aplicaciones y plataformas.
· Puedes crear una representación XML (objeto XmlDataDocument) basada en información del DataSet. Resulta que puedes trabajar con información en un DataSet de dos maneras: relacional convencional (con el propio DataSet) y métodos XML. Ambas vistas se sincronizan automáticamente (cuando se realizan cambios a través de cualquiera de las vistas).
· Puedes aplicar transformaciones XSLT a datos almacenados en un DataSet.
Ahora hablemos de cómo se ve todo esto en la práctica.
Atenuar ds como nuevo conjunto de datos()
ds.ReadXml(Server.MapPath("nombredearchivo.xml"))
El método MapPath para un objeto Servidor especial le permite convertir la ruta virtual de un archivo en una aplicación web en una ruta física.
Si la estructura del DataSet se genera automáticamente a partir del archivo XML o permanece igual depende de si ya se ha generado en ese DataSet y de si se especificó el parámetro opcional ReadXml XmlReadMode.
Atenuar ds como nuevo conjunto de datos()
Dim da como nuevo SqlDataAdapter(_
"seleccionar * de Autores", conexión)
da.Fill(ds)
ds.WriteXml(Server.MapPath("nombredearchivo.xml"))
Hay dos métodos más que le permiten obtener datos en formato XML de un DataSet y colocarlos en una variable de cadena. Estos son los métodos GetXml y GetXmlSchema. Un ejemplo podría verse así:
OscurostrXmlDSComoCadena =ds.ObtenerXml()
Un DataSet a menudo contiene objetos DataTable conectados entre sí mediante DataRelations (es decir, tablas con una clave primaria y externa). Al exportar a XML, la información de la tabla principal se puede complementar con información de la tabla secundaria. Los registros de la tabla subordinada aparecerán como elementos anidados para los registros de la tabla principal. Para implementar esta característica, debe establecer la propiedad anidada en Verdadero para el objeto DataRelation en el conjunto de datos (el valor predeterminado es Falso).
Digamos que simplemente exportamos los datos sin usar esta propiedad:
Atenuar ds como nuevo conjunto de datos()
'llenar el conjunto de datos
...
Dim parentCol como columna de datos = _
ds.Tables("Editores").Columns("pub_id")
Dim childCol como columna de datos = _
ds.Tables("Títulos").Columnas("pub_id")
ds.Relations.Add(dr)
ds.WriteXml(Server.MapPath("PubTitlesNotNested.xml"), _
XmlWriteMode.IgnoreSchema)
El código XML se ve así:
y ahora lo usamos para establecer la propiedad Anidada del objeto DataRelation en Verdadero:
Dim dr como nueva relación de datos _
("TítuloEditores", parentCol, childCol)
dr.Anidado = Verdadero
ds.Relations.Add(dr)
ds.WriteXML(Server.MapPath("PubTitlesNested.xml"), _
Modo de escritura XML.Ignorar esquema)
El código XML resulta completamente diferente. Cada elemento del tipo Pub contiene elementos de Títulos publicados por este editor:
XmlDataDocument es una representación XML en memoria de datos en un DataSet. Un XmlDataDocument está inextricablemente vinculado a un DataSet. Cualquier cambio realizado en XmlDataDocument se refleja inmediatamente en el DataSet y viceversa. A continuación hablaremos sobre técnicas para trabajar con XmlDataDocument.
DataSet es una representación relacional de datos, mientras que XmlDataDocument es jerárquico. Usar XmlDataDocument es muy conveniente, ya que trabajar con datos en formato XML solo a través de un DataSet puede resultar difícil. Por ejemplo, si carga datos de un archivo XML en un DataSet y luego los vuelve a descargar, puede resultar que el archivo sea irreconocible: se perderá el formato, muy posiblemente el orden de los elementos, tal vez elementos que se ignoraron debido a a inconsistencia con el esquema definido para el DataSet.
Puede colocar un documento XML directamente en un XmlDataDocument o puede crearlo basándose en un DataSet. El código para la primera opción podría verse así:
Atenuar objXmlDataDoc como nuevo XmlDataDocument()
objXmlDataDoc.Load(Server.MapPath("archivo.xml"))
o así:
objXmlDataDoc.DataSet.ReadXml(Server.MapPath("archivo.xml"))
No habrá ninguna diferencia.
O puede crear primero un DataSet, llenarlo con datos y luego crear un XmlDataDocument basado en él:
Atenuar ds como nuevo conjunto de datos()
'completar ds
...
Dim objXmlDataDoc como nuevo XmlDataDocument(ds)
Una vez creado el objeto XmlDataDocument, puedes realizar varias acciones sobre él:
· vincularse a DataGrid y otros controles:
dg.DataSource = objXmlDataDoc.DataSet
· obtener la cadena requerida (se devuelve como un objeto XmlElement):
Atenuar elem como XmlElement
elem = objXmlDataDoc.GetElementFromRow_
(ds.Tables(0).Filas(1))
· utilizar el conjunto completo de propiedades y métodos DOM. XmlDataDocument hereda estas propiedades y métodos del objeto XmlDocument
· aplicar transformaciones XSLT (los objetos XslTransform se utilizan para este propósito).
Obtenga más información sobre las transformaciones XSLT:
XSLT le permite transformar un documento XML de origen en otro documento que difiere en formato y estructura. Por ejemplo, utilizando XSLT, un documento XML se puede convertir a código HTML para mostrarlo en una aplicación web. ASP.NET utiliza la clase XslTransform para realizar transformaciones XSLT.
¿Cómo es trabajar con él?
· para realizar transformaciones, primero es necesario crear un DataSet y el XmlDataDocument correspondiente:
Atenuar ds como nuevo conjunto de datos()
'rellenar conjunto de datos
...
Atenuar xmlDoc como nuevo XmlDataDocument(ds)
· siguiente acción: crear un objeto XslTransform:
Atenuar xslTran como nuevo XslTransform()
· use el método Load de este objeto para cargar la transformación en él:
xslTran.Load(Server.MapPath("PubTitles.xsl"))
· crear un objeto XmlTextWriter (se utilizará para mostrar los resultados de la transformación):
Escritor tenue como nuevo XmlTextWriter _
(Server.MapPath("PubTitles_output.html"), _
Sistema.Texto.Codificación.UTF8)
· Realizamos la transformación propiamente dicha utilizando el método Transform del objeto XslTransform. Este método tiene varias opciones. Una forma de usarlo podría verse así:
xslTran.Transform(xmlDoc, Nada, escritor)
· cerrar el objeto Escritor:
escritor.Cerrar()
Para trabajar con XML en un formulario web, puede prescindir de un objeto DataSet (y de controles diseñados para mostrar datos de una fuente relacional). En su lugar, puede utilizar el control de servidor web XML. Le permite mostrar los propios documentos XML o los resultados de sus transformaciones en una página web. El código XML se puede pasar a este control de diferentes maneras:
· abrirlos directamente desde el disco (a través de la propiedad DocumentSource). En este caso (si no ha aplicado transformaciones XSLT), el documento XML se generará en el formato "tal cual":
Ejemplo XML
TransformSource="MyStyle.xsl" runat="servidor" />
· abrirlos como objetos y pasarlos a este control (a través de la propiedad Documento). En nuestro caso Web XML El control del servidor se llama Xml1:
Subpágina privada_carga (remitente ByVal como System.Object, _
ByVal y As System.EventArgs) maneja MyBase.Load
Dim xmlDoc como System.Xml.XmlDocument = _
Nuevo System.Xml.XmlDocument()
xmlDoc.Load(Server.MapPath("MiFuente.xml"))
Dim xslTran como System.Xml.Xsl.XslTransform = _
Nuevo System.Xml.Xsl.XslTransform()
xslTran.Load(Server.MapPath("MiEstilo.xsl"))
Xml1.Documento = xmlDoc
Xml1.Transformar = xslTran
Subtítulo final
· simplemente genere código XML mediante programación y pase ese código XML al control del servidor web (a través de la propiedad DocumentContent)
· en general, ingrese directamente el código XML en la etiqueta XML Web Server Control:
realizar la transformación y transferirle los resultados de la transformación
A continuación se presenta un ejemplo que ilustra todas estas posibilidades:
Document="Objeto XmlDocument a mostrar"
DocumentContent="Cadena de XML"
DocumentSource="Ruta al documento XML"
Transform="objeto XslTransform"
TransformSource="Ruta al documento de transformación XSL"
runat = "servidor ">
Puede agregar un control de servidor web XML a un formulario web simplemente arrastrando este control desde ToolBox o mediante programación:
< áspid:XMLidentificación="xmlCtl"runat = "servidor "/>
XMLCtl.Documento.Ahorrar (Servidor.RutaMapa("xmlResultado.xml "))
Ha pasado bastante tiempo desde que prometí hablar sobre cómo trabajar con datos en formato XML al desarrollar aplicaciones .NET. Las promesas deben cumplirse. Tenga en cuenta que este artículo no está dirigido a desarrolladores profesionales de .NET, sino a aquellos que aún no tienen una experiencia significativa en la creación de aplicaciones .NET.
¿Por qué deberíamos trabajar con XML?
Si aún no tiene una idea muy clara de qué es XML, le recomiendo leer el artículo "XML es serio y durante mucho tiempo" en "KV" No. de 2007. Para ahorrar espacio para cosas más importantes, el formato XML en sí no se analizará aquí.
Antes de comenzar a familiarizarse con el código del programa, debe responder una pregunta fundamental: ¿por qué incluir soporte XML en su aplicación? Creo que mucha gente se ha hecho esta pregunta con respecto a muchas tecnologías, y no todas se incluyeron en las aplicaciones después de la respuesta. Sin embargo, con XML la situación es algo diferente y existen razones reales para utilizar este formato en muchas situaciones.
La principal ventaja de XML es que, al ser un formato de texto por naturaleza, permite perfectamente almacenar y transmitir cualquier dato. Dado que este formato es texto, el problema de su multiplataforma se resuelve por sí solo y el problema de la transmisión de datos XML se resuelve con la misma facilidad (como se hace, por ejemplo, en SOAP). Además, podrás cambiar fácilmente el formato de transferencia o almacenamiento de datos añadiendo nuevos atributos y sin preocuparte demasiado por la compatibilidad con versiones anteriores del formato, ya que las aplicaciones que utilicen la versión antigua podrán leer lo que necesiten sin prestar atención a las nuevas. etiquetas o atributos. Muchas aplicaciones utilizan formatos de archivo basados en XML, muchos protocolos de transferencia de datos también se basan en XML y las listas de ambos siguen creciendo.
Por otro lado, XML no es muy económico porque, como señaló correctamente uno de los visitantes del foro Computer News, los documentos XML a menudo constan de un 10% de datos y un 90% de etiquetas. Sin embargo, esto depende en gran medida de las etiquetas que elija. puedes escribir
Entonces, en las manos adecuadas, XML es algo poderoso y conveniente y, debido a la ubicuidad de este formato, no puedes escapar de él en absoluto. Entonces pasemos a escribir el código del programa.
Para programar usaremos el lenguaje principal de la plataforma .NET: C#. Para que el mayor número posible de lectores practiquen ellos mismos con el código del programa dado, utilizaré la primera versión de C# y .NET Framework.
Grabación de datos
Primero, hablemos de escribir datos, porque, ya sabes, para leer algo de algún lugar, primero debes escribir algo en algún lugar. Y desde que usted y yo comenzamos a programar, no es apropiado que creemos datos XML manualmente. Entonces, primero comencemos escribiendo los datos en XML.
Primero, cree un nuevo proyecto en Visual Studio, #Develop o C# Builder y agregue System.Xml a la lista de espacios de nombres importados.
Una clase especial, XmlTextWriter, es responsable de escribir datos XML en .NET Framework, lo que le permite escribir datos XML en un flujo arbitrario, es decir, en términos generales, podemos usarlos para escribirlos en un archivo, una base de datos. y enviarlo a alguien a través de Internet, pero ahora escribiremos todo en un archivo. Puede redirigir la salida cambiando el constructor del objeto (es decir, pasando no el nombre del archivo y su codificación durante la inicialización, sino un objeto que es un dato). stream). Parece que ya me estoy adelantando un poco. Primero, familiaricémonos con el código responsable de escribir datos en nuestro archivo XML.
String NombreDeArchivo = "c:\\demo.xml"; XmlTextWriter xml = nuevo XmlTextWriter (Nombre de archivo, System.Text.Encoding.Unicode); xml.Formatting = Formateo.Indentado; xml.WriteStartDocument(); xml.WriteStartElement("elemento raíz"); para (int i = 0; i< 10; i++) { xml.WriteStartElement("subelement"); xml.WriteAttributeString("attrib1", "value1"); xml.WriteAttributeString("attrib2", i.ToString()); for (int j = 0; j < 10; j++){ xml.WriteStartElement("subsubelement"); xml.WriteAttributeString("attr", j.ToString()); xml.WriteEndElement(); } xml.WriteEndElement(); } xml.WriteEndElement(); xml.WriteEndDocument(); xml.Close();
Creo que la primera línea es bastante clara: simplemente registra el nombre del archivo en el que guardaremos los datos. A continuación, creamos un objeto del tipo XmlTextWriter (se llama, como puede ver, xml), y es con él que realizaremos todas las operaciones posteriores. Tenga en cuenta que al construir un objeto, también especificamos la codificación en la que se escribirá el XML: en nuestro ejemplo, es Unicode. La siguiente línea, en términos generales, no es necesaria, pero hará que nuestro documento XML, como dicen, sea legible para humanos, es decir, agregará las sangrías necesarias y lo dividirá en líneas. Sin él, todo el documento quedaría escrito en una sola línea, lo que, aunque ahorra espacio, lo hace prácticamente inadecuado para la edición manual.
La escritura del documento comienza llamando al método WriteStartDocument() de nuestro objeto xml. La línea que sigue agrega el elemento raíz "rootelement" a nuestro documento XML (permítanme recordarles que para los documentos XML el elemento raíz debe estar presente en una sola copia). A continuación, en un ciclo, agregamos diez elementos más que no llevan ninguna carga semántica a nuestro documento XML, para cada uno de los cuales establecemos dos atributos y diez subelementos más. Tenga en cuenta que podemos agregar un número a una cadena sin convertir explícitamente los datos, pero si el número debe formar completamente una cadena, entonces debe convertirse explícitamente usando el método ToString(). Tenga en cuenta también que debemos cerrar explícitamente cada uno de los elementos de nuestro documento XML, y luego todo el documento.
Ahora que nuestro documento XML se ha escrito correctamente, veamos cómo podemos leer sus datos.
Leyendo datos
Agregue un componente listBox al formulario de su aplicación (a menos, por supuesto, que sea una aplicación de consola) para que pueda monitorear el resultado de la lectura del archivo XML. Bueno, si tu programa es un programa de consola, entonces puedes redirigir fácilmente la salida a la consola.
Como de costumbre, primero familiaricémonos con el código del programa y luego veremos qué hace exactamente este código.
XmlTextReader xml = nuevo XmlTextReader (Nombre de archivo); xml.WhitespaceHandling = WhitespaceHandling.None; int yo = 0; while (xml.Read())( if ((xml.NodeType == XmlNodeType.Element) & (xml.Name == "subelemento")) ( listBox1.Items.Add("subelemento " + i + " encontrado") ; i++; listBox1.Items.Add(" " + xml.GetAttribute("attrib1")); listBox1.Items.Add(" " + xml.GetAttribute("xml.Name == "subelemento")); )( listBox1.Items.Add(" " + xml.GetAttribute("attr")); ) ) ) xml.Close();
Para leer, como habrás notado, utilizamos otra clase, a saber, XmlTextReader. Está en el mismo espacio de nombres que la clase que usamos para escribir los datos. En la primera línea, creamos una instancia de XmlTextReader, llamada xml (aquí asumimos que la variable FileName ya fue definida por nosotros anteriormente). Para omitir líneas vacías si de alguna manera aparecen inexplicablemente en nuestro archivo XML recién creado, usamos lo siguiente. línea en el fragmento de código dado. La variable i se utiliza para contar el número de elementos "subelementos" que se encuentran en el archivo XML desde el que se leen los datos.
Luego viene el ciclo de lectura directa de datos del archivo. El método Read() lee el siguiente elemento del documento XML y, después de leerlo, comprobamos qué leímos exactamente. Si de hecho es un elemento "subelemento", entonces agregamos información sobre el elemento leído en listBox1, incrementamos una variable que contiene el número de elementos leídos y luego leemos los atributos del elemento. Después de leer los atributos, organizamos un bucle separado para leer los subelementos (tenga en cuenta que no necesitamos un XmlTextReader separado para esto) y los atributos de estos subelementos, como antes, ingresamos toda la información leída en listBox1 para controlar la exactitud de. lectura.
Al leer archivos XML, al igual que al escribirlos, al construir un XmlTextReader, puede especificar como parámetro la secuencia desde la cual leer, y luego puede leer no solo de archivos, sino también de otras fuentes, ejemplos de los cuales tengo Ya se mencionó anteriormente. Cabe señalar una característica útil de la clase XmlTextReader: al leer, no carga todo el documento XML que se lee en la memoria, por lo que es conveniente analizar documentos XML grandes (por ejemplo, bases de datos XML).
Entre bastidores
En general, el ejemplo que acabamos de comentar es demasiado simple para proyectos reales. Hoy en día, a la hora de leer documentos XML se suele validar mediante DTD, XML Schema o Relax NG. La validación es una verificación del cumplimiento del marcado del documento XML con algún estándar descrito en un archivo externo. La validación es necesaria para que la verificación del documento no esté integrada en el algoritmo del programa, sino que pueda cambiarse arbitrariamente cuando cambia el formato de los datos sin actualizar el código del programa que lee o escribe los datos. Desafortunadamente, ahora no tendremos tiempo para resolver la validación porque, como usted mismo comprenderá, el volumen de un artículo periodístico tiene ciertas limitaciones.
Otro punto práctico interesante y útil respecto al trabajo con datos XML es la transformación de datos XSL. Esta transformación se aplica a los datos cuando se muestran en páginas HTML y, de hecho, consiste simplemente en aplicar una plantilla de página web específica a un archivo XML que contiene algunos datos. Dado que la mayor parte del uso actual de datos XML es, de una forma u otra, Mundial Web, entonces sería muy, muy bueno considerar las transformaciones XSL.
Entonces, creo que este artículo tendrá una continuación, pero, por supuesto, solo si usted mismo (es decir, los lectores de Computer News) lo pregunta en el foro o en una carta a mi dirección de correo electrónico. Por ahora, probablemente se trate de usar XML en aplicaciones .NET. Espero que esta información te sea útil.
El lenguaje no es hijo, sino padre del pensamiento.
Óscar Wilde
Abreviatura XML significa Extensible Markup Language, traducido como "lenguaje de marcado extensible". Al igual que HTML, es un subconjunto de SGML (lenguaje de marcado general estándar), el "abuelo" de los lenguajes de marcado. Nos hemos encontrado con el formato XML más de una vez. Este es el formato de los archivos de configuración, un archivo que describe las fuentes de datos de los objetos.
XML es un estándar universal, independiente de la plataforma, para describir información que se puede utilizar para representar datos jerárquicos y unificar la información transferida. Sin conocerlo es imposible entender SOAP y, por tanto, los servicios web. XML se ha convertido en el estándar de facto para la transmisión de datos en Internet. El estándar para XML y formatos relacionados está definido por el W3C (World Amplia red Consorcio). Por ejemplo, creamos páginas aspx en formato XHTML, una transición entre HTML y XML, cuyo estándar también está definido por el W3C. El estándar XHTML impone reglas más estrictas sobre la correcta formación de un documento, similares a las reglas de XML.
Entendamos la principal diferencia entre XML y HTML. XML está diseñado para describir datos y centrarse en qué son exactamente. HTML está diseñado para mostrar datos y se centra en su apariencia. Si en HTML tradicional los conceptos de "presentación" y "visualización" a menudo se confunden, cuando trabajamos con XML separamos claramente estos conceptos. Las etiquetas XML no están predefinidas por los creadores del lenguaje, a diferencia de las etiquetas HTML. Cada autor del documento define sus propias etiquetas.
El estándar requiere que un programa que procesa un documento XML se detenga si encuentra un error. Y si el navegador detecta una etiqueta poco clara en el HTML, o la ausencia de una etiqueta de cierre, simplemente la ignora.
Al principio de un documento XML siempre aparece su declaración o prólogo. Especifica la versión del estándar XML al que se ajusta.
es un error en XML.
Las etiquetas pueden tener atributos. Los valores de los atributos deben estar entre comillas. El orden de los atributos no importa. Puede haber texto entre las etiquetas de apertura y cierre. XML conserva todos los espacios en blanco que se encuentran en el texto. Si no hay texto, puede utilizar una forma de notación abreviada. Ejemplo de etiqueta XML:
| |
Esta es una forma corta de la etiqueta.
| |
¿Esto te recuerda algo? Las reglas para describir elementos ASP.NET son exactamente las mismas.
Hay un atributo xmlns que define el espacio de nombres. Su valor puede ser cualquier nombre único. Existe un acuerdo para utilizar URL porque son únicas. Los espacios de nombres tienen un significado similar a cómo se usan en .NET Framework, para evitar mezclar nombres similares utilizados por diferentes desarrolladores. El nombre del espacio de nombres está separado del nombre por dos puntos.
Los archivos XML representan información jerárquica que se puede representar como un árbol con una única raíz.
Los documentos XML que satisfacen todos los requisitos de sintaxis se denominan bien formados. Para describir datos, XML utiliza DTD (Definición de tipo de documento), una definición del tipo de documento. Si el archivo coincide con la DTD, se considera válido.
Los navegadores IE 6.0, FireFox 1.5 muestran archivos XML con resaltado de sintaxis. Los nodos principales se pueden expandir y cerrar. Por ejemplo, cuando está cerrado, el nodo raíz del archivo BirthDay.xml tiene este aspecto:
Los entornos de desarrollo Visual Studio y VWD Express comprueban la exactitud de los documentos xml directamente durante la edición.
AdRotator
Elemento de control AdRotator le permite mostrar banners publicitarios y reemplazarlos automáticamente por otros. Los propios banners se describen en un archivo XML u otra fuente de datos. El anuncio se actualiza cada vez que se actualiza la página. La propiedad AdvertismentFile especifica el nombre del archivo XML. El esqueleto de un archivo XML es el siguiente.
|
|
Dentro del nodo Anuncios hay nodos
Estos nodos tienen 5 atributos, todos los cuales son opcionales.
Un ejemplo de un archivo AdvertismentFile se llama ads.xml.
|
|
Se coloca un elemento de control en la página. Su propiedad AdvertisementFile apunta a este archivo.
| |
Si se establece la propiedad Palabra clave, el control muestra solo anuncios que coinciden con su contenido. Dado que se puede cambiar dinámicamente, puede adaptar la publicidad a las necesidades del usuario. La palabra clave debe aparecer al menos una vez en el archivo del anuncio; de lo contrario, aparecerá un rectángulo vacío en lugar de un anuncio.
En versiones anteriores de ASP.NET, sólo se podía trabajar con archivos XML. Ahora puede utilizar cualquier fuente de datos vinculándola al control de fuente de datos. En este caso, debe especificar al menos 3 campos de origen en las propiedades ImageUrlField, NavigateUrlField y AlternateTextField.
| |
Archivos de conversión de documentos
Se sabe que CSS (Cascading Stylesheets) se utiliza a menudo para formatear archivos HTML, aunque esto no es necesario ya que los navegadores asocian una determinada apariencia con todas las etiquetas. Elemento
Establece el párrafo - negrita: el navegador sabe cómo mostrarlos.
Dado que XML no utiliza etiquetas predefinidas, su significado puede ser cualquier cosa:
|
Para generar transformaciones XSLT para cada elemento XML, utilice la etiqueta XSL xsl:for-each. El elemento :for-each localiza elementos en el documento XML y repite el patrón para cada uno.
Los datos se pueden ordenar usando la etiqueta xsl:sort, que debe estar dentro del elemento xsl:for-each:
El aspecto final del archivo de transformación:
Citas famosas
|
Si desea ver el resultado de la transformación del documento en el navegador, incluya una declaración después de la declaración XML
| , |
o seleccione Mostrar salida XML en el menú XML y especifique el archivo de transformación.
El mismo documento XML se puede transformar utilizando otro archivo XSL:
Maestros del aforismo |
El resultado serán citas separadas por una línea horizontal.
Archivos de definición de esquema de documento
Según el estándar moderno, un documento válido debe coincidir con el archivo asociado a él. XSD(Definición de esquema XML): un archivo de definición de esquema XML que define un lenguaje particular, es decir, describe qué elementos y tipos pueden aparecer en un documento. Los esquemas XSD están destinados a reemplazar DTD (Definición de tipo de documento), la diferencia entre ellos es que los archivos XSD también usan sintaxis XML. Los esquemas XSD le permiten determinar qué etiquetas están permitidas, si son obligatorias o no, si se pueden repetir en un documento, etc. Por lo tanto, XML describe datos y XSD describe la estructura de esos datos o metadatos. En términos de programación, XSD es una descripción de tipos, mientras que un archivo XML describe objetos de esos tipos. Un borrador de trabajo del estándar XSD 1.1 está disponible en http://www.w3.org/TR/2003/WD-xmlschema-11-req-20030121/.
El archivo de definición de esquema comienza con una descripción del prefijo del espacio de nombres, que luego se incluye en todos los elementos del archivo. http://tempuri.org se utiliza para configurar el URI para los espacios de nombres ASP.NET.
Por ejemplo, esta definición especifica que el elemento "Autor" es de tipo cadena, debe aparecer una y sólo una vez y, si no se especifica, toma el valor "Pushkin".
| |
El parámetro maxOccurs="unbounded" especifica que el elemento puede aparecer cualquier número de veces.
El parámetro ref le permite hacer referencia a un elemento o atributo global ya descrito en un archivo determinado para evitar repetir los mismos elementos.
- Definir tipos simples y complejos.
XSD tiene tipos predefinidos, muy parecidos a .NET. Se convierten a tipos .NET mientras se ejecuta la aplicación. A partir de ellos, se pueden construir tipos complejos similares a las estructuras de los lenguajes de programación. Un tipo complejo consta de una secuencia de declaraciones de elementos. Definamos un tipo complejo
| |
Etiqueta
Etiqueta
El siguiente ejemplo define un tipo simple anidado dentro de la definición del elemento MyValue.
- Agregue nuevos grupos y grupos de atributos.
Una definición de tipo compleja puede incluir atributos. Digamos que queremos crear un esquema para un archivo como este:
Los atributos sólo pueden ser de tipos simples.
- Añade anotaciones.
Las anotaciones le permiten insertar descripciones de elementos existentes, agregando así documentación al archivo.
| |
Puede editar archivos XSD en Visual Studio 2005 tanto a través del código fuente como utilizando el diseñador. Para un documento XML, puede generar automáticamente un esquema correspondiente. En la ventana de propiedades del documento XML, puede especificar tanto un archivo de esquema como un archivo de transformación. En este caso, Studio verifica automáticamente que el archivo cumpla con el esquema e incluso IntelliSense sustituye las etiquetas de este archivo.
Clase XMLReader
Con la clase XmlReader, puede recuperar datos de documentos XML más rápido que otros métodos.
XmlReader es una clase abstracta. Para comenzar a leer, se pasa un objeto de la clase XmlReaderSettings al método estático Create. Esta función cuenta el número de nodos en un documento.
| usando System.Xml; |
usando System.IO;
privado int CountNodes(string xmlFile) ( int NodesCount=0; XmlReaderSettings settings = new XmlReaderSettings(); settings.IgnoreWhitespace = true; settings.IgnoreComments = true; usando (XmlReader Reader = XmlReader.Create(xmlFile, settings)) ( while ( lector.Read()) ( if (reader.NodeType == XmlNodeType.Element) ( NodesCount++; ) ) devuelve NodesCount;
| La clase XmlReader le permite recuperar clases CLR de un documento. Tengamos un menú de restaurante. |
Escribamos una función que calcule la suma de precios y calorías en el menú.
protegido vacío Page_Load (remitente del objeto, EventArgs e) ( int ItemsCount = 0; decimal DishesTotal = 0; UInt16 CaloriesTotal = 0; configuración de XmlReaderSettings = new XmlReaderSettings(); settings.IgnoreWhitespace = true; NameTable nt = new NameTable(); objeto comida = nt.Add("comida"); precio del objeto = nt.Add("precio" objeto calorías = nt.Add("calorías"); MenuFile = Path.Combine(Request.PhysicalApplicationPath, "menu.xml" ); if (reader.NodeType == XmlNodeType.Element && precio.Equals(reader.LocalName)) ( DishesTotal += (UInt16)reader.ReadElementContentAsDecimal(); ) if (reader.NodeType == XmlNodeType.Element && calorías.Equals(reader .LocalName)) ( CaloriesTotal += (UInt16)reader.ReadElementContentAsInt(); ) ) Response.Write(String.Format("Usted pidió (0) comidas con valor de (1:C), (2) calorías", ItemsCount, DishesTotal , CaloríasTotal));
)
| <% XPathDocument doc = new XPathDocument(Server.MapPath("App_Data\\Quotes.xml")); XslCompiledTransform xsl = new XslCompiledTransform(); xsl.Load(Server.MapPath("App_Data\\Quotes.xsl")); xsl.Transform(doc, null, Response.OutputStream); %> |
Clase XPathDocument
La clase proporciona lectura y almacenamiento en memoria de documentos XML para transformaciones utilizando XSL. Puede navegar por el documento en cualquier dirección y obtener acceso aleatorio a cualquier elemento utilizando expresiones XPath.
Tomemos el documento XML "Quotes.xml" y el archivo de transformación XSL "Quotes.xsl". El resultado de la transformación del documento XML se enviará al flujo de salida de la página.
En el ejemplo anterior, se podría lograr el mismo resultado colocando un control XML en la página.
| |
Fuente de datos XML
El elemento de origen de datos XMLDataSource proporciona una forma sencilla de conectar documentos XML como orígenes de datos con elementos que muestran información. También puede especificar una consulta XPath para filtrar los datos. Al igual que SqlDataSource, le permite editar, eliminar y agregar registros de datos. Para hacer esto, debe acceder al objeto XmlDataDocument ubicado en él llamando al método GetXmlDocument. Después de editarlo, el documento se guarda utilizando el método Guardar.
A diferencia de los datos tabulares en un DBMS, los datos de los archivos XML son jerárquicos, por lo que es conveniente vincular XMLDataSource a controles jerárquicos, como Menú.
Sintaxis de enlace de datos XML
A medida que las aplicaciones utilizan datos XML cada vez con más frecuencia, se ha introducido un método para vincular los datos obtenidos de XMLDataSource.
Estos métodos funcionan de la misma manera que Bind y Eval, que se analizaron en la Conferencia 7.
Apliquemos esta sintaxis a un elemento DataList que recibe datos de un XmlDataSource:
Conclusión
En esta conferencia analizamos cómo trabajar con datos XML. XML proporciona una forma universal de describir e intercambiar información estructurada, independientemente de las aplicaciones y los desarrolladores. Esto completa la consideración de trabajar con fuentes de datos.
En el primer artículo del blog .NET, "Trabajar con XML", las personas en los comentarios exigieron un artículo sobre LINQ to XML. Bueno, intentemos revelar los principios de funcionamiento de esta nueva tecnología de Microsoft.
Creemos una base para mantener un catálogo de grabaciones de audio. La base de datos estará formada por pistas:
- Nombre
- Ejecutor
- Álbum
- Duración
Primero, creemos una aplicación de consola (escribo mis proyectos en C#, pero la esencia generalmente será clara para todos) y conectemos el espacio de nombres necesario.
Usando System.Xml.Linq;
Generando archivos XML
Creemos un archivo XML de nuestra base de datos que contenga varios registros de prueba usando LINQ:
//establece la ruta a nuestro archivo XML de trabajo string fileName = "base.xml"; //contador del número de pista int trackId = 1; //Creación por constructores anidados. XDocument doc = nuevo XDocument(nuevo XElement("biblioteca", nuevo XElement("pista", nuevo XAttribute("id", trackId++), nuevo XAttribute("género", "Rap"), nuevo XAttribute("tiempo", " 3:24"), nuevo XElement("nombre", "Who We Be RMX (con 2Pac)"), nuevo XElement("artista", "DMX"), nuevo XElement("álbum", "")), nuevo XElement("pista", nuevo XAttribute("id", trackId++), nuevo XAttribute("género", "Rap"), nuevo XAttribute("hora", "5:06"), nuevo XElement("nombre", "Angel (con Regina Bell)"), nuevo XElement("artista", "DMX"), nuevo XElement("álbum", "...And Then There Was X")), nuevo XElement("pista", nuevo XAttribute("id", trackId++), nuevo XAttribute("género", "Break Beat"), nuevo XAttribute("hora", "6:16"), nuevo XElement("nombre", "Dreaming Your Dreams") , nuevo XElement("artista", "Hybrid"), nuevo XElement("álbum", "Wide Angle")), nuevo XElement("pista", nuevo XAttribute("id", trackId++), nuevo XAttribute("género" , "Break Beat"), nuevo XAttribute("hora", "9:38"), nuevo XElement("nombre", "Finished Symphony"), nuevo XElement("artista", "Híbrido"), nuevo XElement(" álbum", "Gran Angular")))); //guardamos nuestro documento doc.Save(fileName);
Ahora, después del lanzamiento, aparecerá un archivo XML con el siguiente contenido en la carpeta de nuestro programa:
Para crear un archivo de este tipo usando XmlDocument, el código requirió aproximadamente 2 veces más. En el código anterior utilizamos el constructor de la clase XDocument, que toma como parámetro una lista de elementos secundarios con los que inicialmente queremos inicializar el documento. El constructor XElement utilizado toma como parámetro el nombre del elemento que estamos creando, así como una lista de elementos inicializadores. Convenientemente, podemos configurar nuevos XElement y XAttribute en estos elementos. Estos últimos se representarán en nuestro archivo como atributos de forma independiente. Si no le gusta utilizar este tipo de anidamiento de constructores y considera que dicho código es engorroso, puede reescribirlo en una versión más tradicional. El siguiente código generará un archivo XML similar:
XDocumento doc = nuevo XDocumento(); Biblioteca XElement = new XElement("biblioteca"); doc.Add(biblioteca); //crea el elemento "pista" XElement track = new XElement("track"); //agregar los atributos necesarios track.Add(new XAttribute("id", 1)); track.Add(new XAttribute("género", "Rap")); track.Add(new XAttribute("hora", "3:24")); //crea el elemento "nombre" XElement nombre = new XElement("nombre"); name.Value = "Quienes somos RMX (con 2Pac)";
track.Add(name);
//создаем элемент "artist"
XElement artist = new XElement("artist");
artist.Value = "DMX";
track.Add(artist);
//Для разнообразия распарсим элемент "album"
string albumData = "!}
Naturalmente, es necesario elegir el método necesario según la situación.
Leer datos de un archivo
//establece la ruta a nuestro archivo XML de trabajo string fileName = "base.xml"; //leer datos del archivo XDocument doc = XDocument.Load(fileName); //revisamos cada elemento en la nueva biblioteca //(este elemento es accesible inmediatamente a través de la propiedad doc.Root) foreach (XElement el in doc.Root.Elements()) ( //Muestra el nombre del elemento y el valor del atributo id Console.WriteLine(" (0) (1)", el.Name, el.Attribute("id").Value); Console.WriteLine(" Attributes:"); atributos en un bucle, al mismo tiempo vemos como se convierten en una cadena foreach (XAttribute attr en el.Attributes()) Console.WriteLine(" (0)", attr Console.WriteLine(" Elements:" ); // imprime los nombres de todos los elementos secundarios y sus valores en un bucle foreach (elemento XElement) en el.Elements()) Console.WriteLine(" (0): (1)", elemento.Nombre, elemento .Valor )
Creo que aquí en el código no hay nada complicado y se proporcionan comentarios. Después de ejecutar nuestro programa, se mostrará el siguiente resultado en la consola:
Atributos de la pista 1: id="1" género="Rap" time="3:24" Elementos: nombre: Who We Be RMX (feat. 2Pac) artista: DMX álbum: The Dogz Mixtape: Who"s Next?! pista 2 Atributos: id="2" género="Rap" time="5:06" Elementos: nombre: Angel (ft. Regina Bell) artista: DMX álbum: ...And Then There Was X track 3 Atributos: id= "3" género="Break Beat" tiempo="6:16" Elementos: nombre: Dreaming Your Dreams Artista: Álbum híbrido: Pista gran angular 4 Atributos: id="4" género="Break Beat" tiempo="9: 38" Elementos: nombre: Artista sinfónico terminado: Álbum híbrido: Wide Angle
Cambiando datos
Intentemos revisar todos los nodos de la biblioteca y aumentar el atributo Id del elemento de pista en 1.
(No escribiré más la declaración de la ruta al archivo y el resultado de la salida a la consola, para no sobrecargar el artículo con información innecesaria, compilé todo, todo funciona :)):
//Obtiene el primer nodo secundario de la biblioteca XNode node = doc.Root.FirstNode; while (node != null) ( //comprueba que el nodo actual es un elemento if (node.NodeType == System.Xml.XmlNodeType.Element) ( XElement el = (XElement)node; //obtiene el valor de el atributo id y convertirlo en Int32 int id = Int32.Parse(el.Attribute("id").Value); //aumentar el contador en uno y asignar el valor nuevamente el.Attribute("id"). Valor = id.ToString() ; // pasar al siguiente nodo nodo = node.NextNode ) doc.Save(fileName);
Ahora intentemos hacer esto de una manera más correcta para nuestras tareas:
Foreach (XElement el in doc.Root.Elements("track")) ( int id = Int32.Parse(el.Attribute("id").Value); el.SetAttributeValue("id", --id); ) doc.Save(nombre de archivo);
Como puede ver, este método nos convenía mejor.
Agregar una nueva entrada
Agreguemos una nueva pista a nuestra biblioteca y, al mismo tiempo, calculemos la siguiente identificación única para la pista usando LINQ:
Int maxId = doc.Root.Elements("track").Max(t => Int32.Parse(t.Attribute("id").Value)); Pista XElement = nuevo XElement("pista", nuevo XAttribute("id", ++maxId), nuevo XAttribute("género", "Break Beat"), nuevo XAttribute("tiempo", "5:35"), nuevo XElement("nombre", "Más alto que un rascacielos"), nuevo XElement("artista", "Híbrido"), nuevo XElement("álbum", "Morning Sci-Fi")); doc.Root.Add(pista); doc.Save(nombre de archivo);
Con una consulta tan elevada a todos los elementos, se calcula el valor máximo del atributo id de las pistas. Al sumar, incrementamos el valor máximo resultante. Agregar un elemento en sí se reduce a llamar al método Agregar. Tenga en cuenta que estamos agregando elementos a Root, ya que de lo contrario romperemos la estructura del documento XML al declarar 2 elementos raíz allí. Además, no olvides guardar tu documento en el disco, ya que hasta que no lo guardes, ningún cambio en nuestro XDocument se reflejará en el archivo XML.
Eliminando elementos
Intentemos eliminar todos los elementos del artista DMX:
IEnumerable
En este ejemplo, primero seleccionamos todas las pistas cuyo elemento secundario cumplió por primera vez con los criterios y luego eliminamos estos elementos en un bucle. Es importante la llamada al final de la selección a ToList(). Al hacer esto, registramos en un área de memoria separada todos los elementos que queremos borrar. Si decidimos eliminar del conjunto de registros que estamos recorriendo directamente en el bucle, obtendremos la eliminación del primer elemento y la posterior NullReferenceException. Por eso es importante recordar esto.
Según el consejo de xaoccps, puedes eliminarlo de una forma más sencilla:
IEnumerable
En este caso, no es necesario convertir nuestro resultado resultante en una lista llamando a la función ToList(). ¿Por qué este método no se describió originalmente en
Presentamos a su atención un nuevo curso del equipo. El código- “Pruebas de penetración de Aplicaciones Web desde cero”. Teoría general, preparación del entorno de trabajo, fuzzing pasivo y toma de huellas dactilares, fuzzing activo, vulnerabilidades, post-explotación, herramientas, ingeniería social y mucho más.
XML DOM 2
El artículo anterior describió conceptos generales sobre XML. En este artículo aprenderemos cómo realizar acciones básicas relacionadas con cambiar, agregar y buscar en un archivo XML.
Archivo XML que se utiliza para el ejemplo.
dominio xml
Por el momento, nuestro fichero contiene la siguiente estructura:
Relación entre nodos en XMLDOM, puntos principales:
1. Cualquier nodo en el árbol DOM tiene un ParentNode principal. En nuestro ejemplo, el garaje es el padre de ambos elementos del automóvil y ambos elementos del automóvil son, a su vez, padres de los elementos del modelo y del año.
¿Cómo obtener el elemento padre del elemento xml del automóvil?
Console.WriteLine(elmRoot["car"].ParentNode.Name); //Resultado: garaje
2. Un padre puede tener hijos ChildNodes. Por ejemplo, para el nodo de garaje los hijos son ambos elementos del coche. Los elementos del coche también tienen modelo y año infantil.
Nodos secundarios, es una colección que almacena todos los elementos xml secundarios para acceder al elemento deseado, debe especificar su índice. (¡El índice siempre comienza desde cero!)
Por ejemplo: ¿cómo obtener el primer elemento hijo?
ElmRoot.ChildNodes;
3. Como en la vida normal, un niño puede nacer primero como Primer Hijo o como último como Último Hijo.
Si tomamos el elemento automóvil como ejemplo, entonces
FirstChild es el modelo LastChild es el año
4. A su vez, también existen conexiones entre los elementos infantiles; pueden ser hermanos o hermanas, si establecemos paralelismos con la vida real.
Un niño puede tener, por ejemplo, un hermano hermano anterior y un hermano hermano siguiente.
Console.WriteLine(elmRoot.ChildNodes.FirstChild.NextSibling.Name); //Resultado: año Console.WriteLine(elmRoot.ChildNodes.LastChild.PreviousSibling.Name); //Resultado: modelo
Si no se encuentra el elemento, se genera una excepción: NullReferenceException, por lo que cuando trabaje con xml, utilice siempre bloques try catch.
Console.WriteLine(elmRoot.ChildNodes. LastChild.NextSibling.Name); Console.WriteLine(elmRoot.ChildNodes. FirstChild.PreviousSibling.Name);
LastChild es NextSibling;
FirstChild es PreviousSibling;
Con los métodos descritos anteriormente, puede moverse fácilmente al nodo deseado y obtener cualquier valor que necesite.
¿Cómo obtener el valor de un elemento xml?
El valor xml de un elemento se puede obtener usando la propiedad InnerText, por ejemplo:
Console.WriteLine(elmRoot["coche"].FirstChild.InnerText); //Resultado: Mazda
Otra forma de obtener el mismo valor de elemento xml:
Console.WriteLine(elmRoot.FirstChild.FirstChild.InnerText); //Resultado: Mazda
La secuencia de movimientos a lo largo del árbol DOM:
Garaje -> coche -> modelo -> Mazda
Obtenemos el año:
ElmRoot["coche"].LastChild.InnerText; //Resultado: 2007
Subsecuencia:
Garaje -> coche -> año -> 2007
Otro ejemplo: 3 formas de obtener el mismo resultado.
Console.WriteLine(elmRoot.LastChild.FirstChild.InnerText); Console.WriteLine(elmRoot["coche"].NextSibling.FirstChild.InnerText); Console.WriteLine(elmRoot.ChildNodes.Item(1).FirstChild.InnerText); //Resultado: BMW
Si necesitas obtener el año de un elemento con el valor Mazda:
Console.WriteLine(elmRoot.FirstChild.LastChild.InnerText); //Resultado: 2007
Para BMW (de dos maneras, obtenga el mismo resultado)
Console.WriteLine(elmRoot.ChildNodes.Item(1).ChildNodes.Item(1).InnerText); Console.WriteLine(elmRoot.ChildNodes.ChildNodes.InnerText); //Resultado: 2009
¿Cómo cambiar los valores de los elementos xml?
Usando propiedad Texto interno() Puede obtener y cambiar el valor de un elemento xml, por ejemplo, cambiar el año.
//Establece un nuevo valor elmRoot.FirstChild.LastChild.InnerText = "2010"; //Muestra el nuevo valor en la pantalla de la consola Console.WriteLine(elmRoot.FirstChild.ChildNodes.Item(1).InnerText); //Resultado: 2010
Al mismo tiempo, debe recordar que todos los cambios se producen con el archivo xml virtual; si abre el archivo físico, verá que todavía se indica el año 2007;
Para que los cambios surtan efecto, debe utilizar el método Guardar, por ejemplo:
ElmRoot.Save("nombre de archivo xml o secuencia");
Ahora la información se cambiará en el archivo xml “físico”.
¿Cómo obtener la cantidad de elementos secundarios?
Console.WriteLine(elmRoot.FirstChild.ChildNodes.Count);garaje -> el coche contiene 2 niños: modelo y año
Console.WriteLine(elmRoot.FirstChild.FirstChild.ChildNodes.Count);
garaje -> automóvil -> modelo contiene 1 elemento xml secundario.
Accediendo a elementos secundarios
por índice
ElmRoot.ChildNodes.Nombre; elmRoot.ChildNodes.Nombre; //Resultado: coche
Usando un bucle
Foreach (XmlNode asiente en elmRoot.ChildNodes) ( Console.WriteLine(nod.Name); ) //Resultado: auto, auto
¿Cómo obtener el nombre del elemento xml?
elmRoot.Nombre; //Resultado: garajeCreando un nuevo elemento XML
Creemos un nuevo elemento en nuestro documento XML para que se diferencie de los otros dos (coche), llamémoslo bus.
Al crear un nuevo elemento, usaremos la recomendación del sitio web msdn y en lugar del nuevo XmlElement estándar usaremos el método CreateElement.
XmlElement olmo = xmlDoc.CreateElement("bus");
Crear y agregar un nuevo elemento xml
Creemos un nuevo elemento xml llamado "BUS".
XmlElement elmRoot = xmlDoc.DocumentElement; Console.WriteLine(elmRoot.ChildNodes.Count); //coche, coche XmlElement elmNew = xmlDoc.CreateElement("bus"); elmRoot.AppendChild(olmoNuevo); Console.WriteLine(elmRoot.ChildNodes.Count); //3 coche, coche, autobús xmlDoc.Save("nombre de archivo xml");Explicación:
1. Primero, obtenemos un elemento raíz al que adjuntaremos nuevos elementos.
2. Como comprobación, mostraremos el número actual de elementos secundarios del elemento garaje: 2 (coche y coche)
3. Crea un nuevo elemento BUS
4. Usando el método Agregar niño agregando un nuevo elemento al árbol
5. Usemos la verificación nuevamente y mostremos el número actual de elementos para el elemento del garaje, ahora hay 3: automóvil, automóvil, autobús.
6. Para que los cambios afecten al archivo físico, guarde
En el archivo XML, el nuevo elemento tendrá este aspecto:
¿Cómo agregar un nuevo elemento xml?
Tarea: cree un nuevo elemento XML y agréguele contenido de texto, por ejemplo, el año de fabricación.
String strFilename = @"C:\lessons\Auto.xml"; XmlDocument xmlDoc = nuevo XmlDocument(); xmlDoc.Load(strFilename); XmlElement elmRoot = xmlDoc.DocumentElement; XmlElement elmNew = xmlDoc.CreateElement("autobús"); XmlText new_txt = xmlDoc.CreateTextNode("2006"); elmRoot.AppendChild(olmoNuevo); elmRoot.LastChild.AppendChild(new_txt); Console.WriteLine(elmRoot.ChildNodes.Name); //bus Console.WriteLine(elmRoot.ChildNodes.LastChild.InnerText); //2006 Consola.Read();
En archivo XML:
Para mayor claridad
Ahora creemos un nodo “bus” con la misma arquitectura que car, es decir, agreguemos nodos: modelo, año y algo de contenido de texto.
Crear un elemento XML con hijos
string strFilename = @"C:\lessons\Auto.xml"; //crea un nuevo documento xml en la memoria XmlDocument xmlDoc = new XmlDocument(); //carga el archivo xml en la memoria xmlDoc.Load(strFilename); //Obtener el elemento raíz XmlElement elmRoot = xmlDoc.DocumentElement; //Crea 3 elementos: bus, modelo, año XmlElement elmBUS = xmlDoc.CreateElement("bus"); XmlElement elmModel = xmlDoc.CreateElement("modelo"); XmlElement elmYear = xmlDoc.CreateElement("año"); //Establecer valores para elementos: modelo, año XmlText año_txt = xmlDoc.CreateTextNode("2006"); //XmlText mod_txt = xmlDoc.CreateTextNode("liaz"); agregar de lo contrario //Agregar dos elementos secundarios al elemento bus: modelo y año elmBUS.AppendChild(elmModel); elmBUS.AppendChild(elmAño); //Agrega valores a los nodos de modelo y año elmModel.InnerText = "liaz"; elmYear.AppendChild(año_txt); //Agrega un nuevo bus de elementos xml al árbol elmRoot.AppendChild(elmBUS); //Comprueba si todo está agregado como debería Console.WriteLine(elmRoot.ChildNodes.FirstChild.InnerText); Console.WriteLine(elmRoot.LastChild.LastChild.InnerText); //Si todo está en orden, utilice el método Guardar xmlDoc.Save("nombre de archivo xml");Resultado:
¿Cómo puedo acortar este código? Por ejemplo, de la siguiente manera:
String PathXmlFile = @"C:\lessons\Auto.xml"; XmlDocument xmlDoc = nuevo XmlDocument(); xmlDoc.Load(PathXmlFile); XmlElement elmRoot = xmlDoc.DocumentElement; XmlElement elmBUS = xmlDoc.CreateElement("autobús"); XmlElement elmModel = xmlDoc.CreateElement("modelo"); XmlElement elmYear = xmlDoc.CreateElement("año"); //Agrega valores a los nodos de modelo y año elmModel.InnerText = "liaz"; elmYear.InnerText = "2006"; elmBUS.AppendChild(elmModel); elmBUS.AppendChild(elmAño); elmRoot.AppendChild(elmBUS); //Si todo está correcto, llame al método Guardar xmlDoc.Save("nombre de archivo xml");
Acortemos un poco más el código, para ello usaremos la propiedad InnerXml:
XmlDocument xmlDoc = nuevo XmlDocument(); xmlDoc.Load(PathXmlFile); XmlElement elmXML = xmlDoc.CreateElement("autobús"); texto de cadena = "
Resultado
Obtenga una lista de elementos usando GetElementByTagName
GetElementByTagName devuelve Lista de nodos XML, que contiene todos los elementos descendientes que pertenecen al elemento especificado, por ejemplo, necesitamos obtener todos los modelos de automóviles que están almacenados en el garaje:
XmlDocument xmlDoc = nuevo XmlDocument(); xmlDoc.Load(strFilename); XmlNodeList modelName = xmlDoc.GetElementsByTagName("modelo"); foreach (nodo XmlNode en modelName) ( Console.WriteLine(node.InnerText); ) //Resultado: mazda, bmw, liaz
Acceso mediante índice:
String PathXmlFile = @"C:\lessons\Auto.xml"; XmlDocument xmlDoc = nuevo XmlDocument(); xmlDoc.Load(PathXmlFile); XmlNodeList modelName = xmlDoc.GetElementsByTagName("modelo"); Console.WriteLine(modelName.InnerText); //Resultado: liaz
¿Cómo puedo cambiar el contenido del texto de un elemento "bus" recién creado utilizando el método GetElementByTagName?
String PathXmlFile = @"C:\lessons\Auto.xml"; XmlDocument xmlDoc = nuevo XmlDocument(); xmlDoc.Load(PathXmlFile); XmlNodeList modelName = xmlDoc.GetElementsByTagName("modelo"); Console.WriteLine(modelName.InnerText); //Recibido el valor: liaz
O puedes cambiar el nombre liaz a Ikarus
Console.WriteLine(modelName.InnerText = "Ikarus");
