Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

XStreamingElement (Clase)

Representa los elementos de un árbol XML que admite la salida de transmisión por secuencias diferida.

System.Object
  System.Xml.Linq.XStreamingElement

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

public class XStreamingElement

El tipo XStreamingElement expone los siguientes miembros.

  NombreDescripción
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsXStreamingElement(XName)Inicializa una nueva instancia de la clase XElement a partir del XName especificado.
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsXStreamingElement(XName, Object)Inicializa una nueva instancia de la clase XStreamingElement con el nombre y el contenido especificados.
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsXStreamingElement(XName, Object[])Inicializa una nueva instancia de la clase XStreamingElement con el nombre y el contenido especificados.
Arriba

  NombreDescripción
Propiedad públicaCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsNameObtiene o establece el nombre de esta transmisión por secuencias.
Arriba

  NombreDescripción
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsAdd(Object)Agrega el contenido especificado como elementos secundarios a este XStreamingElement.
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsAdd(Object[])Agrega el contenido especificado como elementos secundarios a este XStreamingElement.
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsEquals(Object)Determina si el objeto especificado es igual al objeto actual. (Se hereda de Object).
Método protegidoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsFinalize Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por la recolección de elementos no utilizados. (Se hereda de Object).
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsGetHashCode Sirve como una función hash para un tipo en particular. (Se hereda de Object).
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsGetType Obtiene el Type de la instancia actual. (Se hereda de Object).
Método protegidoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsMemberwiseClone Crea una copia superficial del Object actual. (Se hereda de Object).
Método públicoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsSave(Stream)Envía este XStreamingElement al objeto Stream especificado.
Método públicoCompatible con XNA FrameworkSave(String)Serialice este elemento de transmisión por secuencias en un archivo.
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsSave(TextWriter)Serialice este elemento de transmisión por secuencias en un TextWriter.
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsSave(XmlWriter)Serialice este elemento de transmisión por secuencias en un XmlWriter.
Método públicoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsSave(Stream, SaveOptions)Envía este XStreamingElement al objeto Streamespecificado, especificando opcionalmente el comportamiento de formato.
Método públicoCompatible con XNA FrameworkSave(String, SaveOptions)Serialice este elemento de transmisión por secuencias en un archivo y, de modo opcional, deshabilite el formato.
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsSave(TextWriter, SaveOptions)Serialice este elemento de transmisión por secuencias en un TextWriter, de modo opcional, deshabilite el formato.
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsToString()Devuelve el XML con formato (sangría) para este elemento de transmisión por secuencias. (Invalida a Object.ToString()).
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsToString(SaveOptions)Devuelve el XML de este elemento de transmisión por secuencias y, opcionalmente, se deshabilita el formato.
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsWriteToEscribe este elemento de transmisión por secuencias en un XmlWriter.
Arriba

Esta clase le permite crear un árbol XML que admite la salida de transmisión por secuencias diferida. Puede utilizar esta clase para crear un árbol XML de un modo muy similar a como se crea mediante XElement. Sin embargo, hay una diferencia fundamental. Cuando utiliza una consulta LINQ para especificar el contenido al crear un árbol XML con XElement, se recorre en iteración la variable de consulta en el momento de la construcción del árbol XML y los resultados de la consulta se agregan al árbol XML. En contraste, al crear un árbol XML con XStreamingElement, se almacena una referencia a la variable de consulta en el árbol XML sin que se recorra en iteración. Las consultas sólo se recorren en iteración en la serialización. Esto le permite crear árboles XML de mayor tamaño y mantener una superficie en memoria menor.

Si realiza la transmisión por secuencias desde un origen de entrada, como un archivo de texto, puede leer un archivo de texto de gran tamaño y generar un documento XML de gran tamaño manteniendo una superficie en memoria pequeña.

Otro escenario sería tener un árbol XML de gran tamaño cargado en memoria, y se desea crear una versión transformada del documento. Si crea un nuevo documento con XElement, tendrá dos árboles XML de gran tamaño en memoria durante la realización de la transformación. Sin embargo, si crea el nuevo árbol XML con XStreamingElement, se cortará su espacio de trabajo eficazmente por la mitad.

Observe que cuando se depura un programa que usa XStreamingElement, si se muestra el valor de un objeto, se llama a su método ToString. De esta forma se provoca la serialización del XML. Si la semántica de la consulta del elemento de transmisión por secuencias es tal que este elemento sólo se puede transmitir una vez, se puede provocar un comportamiento indeseable en la experiencia de depuración del usuario.

En el ejemplo siguiente se crea primero un árbol XML de origen. Se crea a continuación una transformación del árbol XML de origen con XElement. Esta transformación crea un nuevo árbol en memoria. Se crea a continuación una transformación del árbol XML de origen con XStreamingElement. Esta transformación no ejecuta la consulta hasta que el árbol transformado se serialice en la consola. Su utilización de memoria es menor.

XElement srcTree = new XElement("Root",
                       new XElement("Child", 1),
                       new XElement("Child", 2),
                       new XElement("Child", 3),
                       new XElement("Child", 4),
                       new XElement("Child", 5)
                   );

XElement dstTree1 = new XElement("NewRoot",
                        from el in srcTree.Elements()
                        where (int)el >= 3
                        select new XElement("DifferentChild", (int)el)
                    );

XStreamingElement dstTree2 = new XStreamingElement("NewRoot",
                        from el in srcTree.Elements()
                        where (int)el >= 3
                        select new XElement("DifferentChild", (int)el)
                    );

Console.WriteLine(dstTree1);
Console.WriteLine("------");
Console.WriteLine(dstTree2);

Este ejemplo produce el siguiente resultado:

<NewRoot>
  <DifferentChild>3</DifferentChild>
  <DifferentChild>4</DifferentChild>
  <DifferentChild>5</DifferentChild>
</NewRoot>
------
<NewRoot>
  <DifferentChild>3</DifferentChild>
  <DifferentChild>4</DifferentChild>
  <DifferentChild>5</DifferentChild>
</NewRoot>

Un enfoque del procesamiento de un archivo de texto es escribir un método de extensión que transmita el archivo de texto de línea en línea mediante la construcción yield return. Después, puede escribir una consulta LINQ que procese el archivo de texto de forma aplazada y lenta. Si después usa XStreamingElement para transmitir el resultado, puede crear una transformación del archivo de texto al XML usando una cantidad mínima de memoria, independientemente del tamaño del archivo de texto de origen.

El siguiente archivo de texto, People.txt, es el origen de este ejemplo.

#This is a comment
1,Tai,Yee,Writer
2,Nikolay,Grachev,Programmer
3,David,Wright,Inventor

El siguiente código contiene un método de extensión que transmite las líneas del archivo de texto de forma diferida.

public static class StreamReaderSequence
{
    public static IEnumerable<string> Lines(this StreamReader source)
    {
        String line;

        if (source == null)
            throw new ArgumentNullException("source");
        while ((line = source.ReadLine()) != null)
        {
            yield return line;
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        StreamReader sr = new StreamReader("People.txt");
        XStreamingElement xmlTree = new XStreamingElement("Root",
            from line in sr.Lines()
            let items = line.Split(',')
            where !line.StartsWith("#")
            select new XElement("Person",
                       new XAttribute("ID", items[0]),
                       new XElement("First", items[1]),
                       new XElement("Last", items[2]),
                       new XElement("Occupation", items[3])
                   )
        );
        Console.WriteLine(xmlTree);
        sr.Close();
    }
}

Este ejemplo produce el siguiente resultado:

<Root>
  <Person ID="1">
    <First>Tai</First>
    <Last>Yee</Last>
    <Occupation>Writer</Occupation>
  </Person>
  <Person ID="2">
    <First>Nikolay</First>
    <Last>Grachev</Last>
    <Occupation>Programmer</Occupation>
  </Person>
  <Person ID="3">
    <First>David</First>
    <Last>Wright</Last>
    <Occupation>Inventor</Occupation>
  </Person>
</Root>

A veces tiene que transformar los archivos XML de gran tamaño y escribir la aplicación para que la superficie en memoria de la aplicación sea predecible. Si intenta rellenar un árbol XML con un archivo XML de gran tamaño, su utilización de memoria será proporcional al tamaño del archivo (es decir, excesivo). Por consiguiente, debe utilizar en su lugar una técnica de transmisión por secuencias.

Ciertos operadores de consulta estándar, como OrderBy, recorren en iteración su origen, recaban todos los datos, los ordenan y finalmente producen el primer elemento de la secuencia. Tenga en cuenta que si utiliza un operador de consulta que materializa su origen antes de producir el primer elemento, no retendrá una superficie de memoria pequeña para la aplicación.

Aun cuando utiliza la técnica descrita en Cómo: Transmitir por secuencias fragmentos de código XML con acceso a la información de encabezado, si intenta ensamblar un árbol XML que contiene el documento transformado, la utilización de memoria puede ser excesiva.

El ejemplo siguiente se basa en otro de Cómo transmitir por secuencias fragmentos XML con acceso a la información de encabezado

Este ejemplo utiliza las funciones de ejecución diferidas de XStreamingElement para transmitir por secuencias el resultado.

Observe que se escribe el eje personalizado (StreamCustomerItem) específicamente para que espere un documento que tiene los elementos Customer, Name e Item, y que esos elementos se organizarán como en el documento Source.xml siguiente. Una implementación más sólida, sin embargo, validaría el documento de origen con XSD o se prepararía para analizar un documento no válido.

A continuación, se muestra el documento de origen, Source.xml:

<?xml version="1.0" encoding="utf-8" ?> 
<Root>
  <Customer>
    <Name>A. Datum Corporation</Name>
    <Item>
      <Key>0001</Key>
    </Item>
    <Item>
      <Key>0002</Key>
    </Item>
    <Item>
      <Key>0003</Key>
    </Item>
    <Item>
      <Key>0004</Key>
    </Item>
  </Customer>
  <Customer>
    <Name>Fabrikam, Inc.</Name>
    <Item>
      <Key>0005</Key>
    </Item>
    <Item>
      <Key>0006</Key>
    </Item>
    <Item>
      <Key>0007</Key>
    </Item>
    <Item>
      <Key>0008</Key>
    </Item>
  </Customer>
  <Customer>
    <Name>Southridge Video</Name>
    <Item>
      <Key>0009</Key>
    </Item>
    <Item>
      <Key>0010</Key>
    </Item>
  </Customer>
</Root>

El código siguiente contiene un método que utiliza XmlReader para transmitir por secuencias el XML de origen. Utiliza XStreamingElement para transmitir por secuencias el nuevo XML.

static IEnumerable<XElement> StreamCustomerItem(string uri)
{
    using (XmlReader reader = XmlReader.Create(uri))
    {
        XElement name = null;
        XElement item = null;

        reader.MoveToContent();

        // Parse the file, save header information when encountered, and yield the
        // Item XElement objects as they are created.

        // loop through Customer elements
        while (reader.Read())
        {
            if (reader.NodeType == XmlNodeType.Element
                && reader.Name == "Customer")
            {
                // move to Name element
                while (reader.Read())
                {
                    if (reader.NodeType == XmlNodeType.Element &&
                        reader.Name == "Name")
                    {
                        name = XElement.ReadFrom(reader) as XElement;
                        break;
                    }
                }

                // loop through Item elements
                while (reader.Read())
                {
                    if (reader.NodeType == XmlNodeType.EndElement)
                        break;
                    if (reader.NodeType == XmlNodeType.Element
                        && reader.Name == "Item")
                    {
                        item = XElement.ReadFrom(reader) as XElement;
                        if (item != null)
                        {
                            XElement tempRoot = new XElement("Root",
                                new XElement(name)
                            );
                            tempRoot.Add(item);
                            yield return item;
                        }
                    }
                }
            }
        }
    }
}

static void Main(string[] args)
{
    XStreamingElement root = new XStreamingElement("Root",
        from el in StreamCustomerItem("Source.xml")
        select new XElement("Item",
            new XElement("Customer", (string)el.Parent.Element("Name")),
            new XElement(el.Element("Key"))
        )
    );
    root.Save("Test.xml");
    Console.WriteLine(File.ReadAllText("Test.xml"));
}

Este ejemplo produce el siguiente resultado:

<?xml version="1.0" encoding="utf-8"?>
<Root>
  <Item>
    <Customer>A. Datum Corporation</Customer>
    <Key>0001</Key>
  </Item>
  <Item>
    <Customer>A. Datum Corporation</Customer>
    <Key>0002</Key>
  </Item>
  <Item>
    <Customer>A. Datum Corporation</Customer>
    <Key>0003</Key>
  </Item>
  <Item>
    <Customer>A. Datum Corporation</Customer>
    <Key>0004</Key>
  </Item>
  <Item>
    <Customer>Fabrikam, Inc.</Customer>
    <Key>0005</Key>
  </Item>
  <Item>
    <Customer>Fabrikam, Inc.</Customer>
    <Key>0006</Key>
  </Item>
  <Item>
    <Customer>Fabrikam, Inc.</Customer>
    <Key>0007</Key>
  </Item>
  <Item>
    <Customer>Fabrikam, Inc.</Customer>
    <Key>0008</Key>
  </Item>
  <Item>
    <Customer>Southridge Video</Customer>
    <Key>0009</Key>
  </Item>
  <Item>
    <Customer>Southridge Video</Customer>
    <Key>0010</Key>
  </Item>
</Root>

.NET Framework

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Biblioteca de clases portable

Compatible con: Biblioteca de clases portable

.NET para aplicaciones de la Tienda Windows

Compatible con: Windows 8

.NET para aplicaciones de Windows Phone

Compatible con: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Todos los miembros static (Shared en Visual Basic) públicos de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft