XStreamingElement Classe

Definição

Representa os elementos em uma árvore XML que dá suporte à saída de transmissão adiada.Represents elements in an XML tree that supports deferred streaming output.

public ref class XStreamingElement
public class XStreamingElement
type XStreamingElement = class
Public Class XStreamingElement
Herança
XStreamingElement

Exemplos

O exemplo a seguir cria primeiro uma árvore XML de origem.The following example first creates a source XML tree. Em seguida, ele cria uma transformação da árvore XML de origem usando XElement .It then creates a transform of the source XML tree using XElement. Essa transformação cria uma nova árvore na memória.This transform creates a new tree in memory. Em seguida, ele cria uma transformação da árvore XML de origem usando XStreamingElement .It then creates a transform of the source XML tree using XStreamingElement. Essa transformação não executa a consulta até que a árvore transformada seja serializada para o console.This transform doesn't execute the query until the transformed tree is serialized to the console. Seu uso de memória é menor.Its memory usage is less.

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);  
Dim srcTree As XElement = _  
        <Root>  
            <Child>1</Child>  
            <Child>2</Child>  
            <Child>3</Child>  
            <Child>4</Child>  
            <Child>5</Child>  
        </Root>  

Dim dstTree1 As XElement = _  
    <NewRoot>  
        <%= From el In srcTree.Elements _  
            Where (el.Value >= 3) _  
            Select <DifferentChild><%= el.Value %></DifferentChild> %>  
    </NewRoot>  

Dim dstTree2 As XStreamingElement = New XStreamingElement("NewRoot", _  
                From el In srcTree.Elements _  
                Where el.Value >= 3 _  
                Select <DifferentChild><%= el.Value %></DifferentChild> _  
            )  

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

Esse exemplo gera a saída a seguir:This example produces the following output:

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

Uma abordagem para processar um arquivo de texto é escrever um método de extensão que passa o arquivo de texto uma linha em uma hora usando a compilação de yield return .One approach to processing a text file is to write an extension method that streams the text file a line at a time using the yield return construct. Você então pode escrever uma consulta LINQ que processa o arquivo de texto em uma forma adiada lazy.You then can write a LINQ query that processes the text file in a lazy deferred fashion. Se você usar o XStreamingElement para transmitir a saída, poderá criar uma transformação do arquivo de texto para XML que usa uma quantidade mínima de memória, independentemente do tamanho do arquivo de texto de origem.If you then use the XStreamingElement to stream output, you then can create a transform from the text file to XML that uses a minimal amount of memory, regardless of the size of the source text file.

O seguinte arquivo de texto, People.txt, é a fonte para esse exemplo.The following text file, People.txt, is the source for this example.

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

O código a seguir contém um método de extensão que passa as linhas do arquivo de texto em uma forma adiada.The following code contains an extension method that streams the lines of the text file in a deferred fashion.

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();  
    }  
}  
Module StreamReaderSequence  

    <Runtime.CompilerServices.Extension>  
    Public Iterator Function Lines(source As IO.StreamReader) As IEnumerable(Of String)  
        If source Is Nothing Then Throw New ArgumentNullException("source")  
        Dim line As String = source.ReadLine()  
        While (line <> Nothing)  
            Yield line  
            line = source.ReadLine()  
        End While  
    End Function  

End Module  

Module Module1  
    Sub Main()  
        Dim sr As New IO.StreamReader("People.txt")  
        Dim xmlTree As New XStreamingElement("Root",  
            From line In sr.Lines()  
            Let items = line.Split(","c)  
            Where Not line.StartsWith("#")  
            Select <Person ID=<%= items(0) %>>  
                       <First><%= items(1) %></First>  
                       <Last><%= items(2) %></Last>  
                       <Occupation><%= items(3) %></Occupation>  
                   </Person>)  
        Console.WriteLine(xmlTree)  
        sr.Close()  
    End Sub  
End Module  

Esse exemplo gera a saída a seguir:This example produces the following output:

<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>  

Às vezes você precisa transformar grandes arquivos XML e escrever seu aplicativo de modo que os requisitos de memória do aplicativo sejam previsíveis.Sometimes you have to transform large XML files, and write your application so that the memory footprint of the application is predictable. Se você tentar preencher uma árvore XML com um arquivo XML muito grande, seu uso de memória será proporcional ao tamanho do arquivo (isto é, excessivo).If you try to populate an XML tree with a very large XML file, your memory usage will be proportional to the size of the file (that is, excessive). Portanto, você deve usar uma técnica de streaming em vez disso.Therefore, you should use a streaming technique instead.

Determinados operadores de consulta padrão, como OrderBy, iteram sua origem, coletam todos os dados, classificam e, em seguida, geram finalmente o primeiro item na sequência.Certain standard query operators, such as OrderBy, iterate their source, collect all of the data, sort it, and then finally yield the first item in the sequence. Observe que se você usar um operador de consulta que materializa sua origem antes de gerar o primeiro item, você não manterá um requisito pequeno de memória para seu aplicativo.Note that if you use a query operator that materializes its source before yielding the first item, you will not retain a small memory footprint for your application.

Mesmo que você use a técnica descrita em, se você tentar montar uma árvore XML que contém o documento transformado, o uso de memória poderá ser muito grande.Even if you use the technique described in , if you try to assemble an XML tree that contains the transformed document, memory usage may be too great.

O exemplo a seguir baseia-se no exemplo em como transmitir fragmentos XML com acesso a informações de cabeçalho.The following example builds on the example in How to stream XML fragments with access to header information.

Este exemplo usa os recursos de execução adiada de XStreamingElement para transmitir a saída.This example uses the deferred execution capabilities of XStreamingElement to stream the output.

Observe que o eixo personalizado (StreamCustomerItem) é escrito especificamente para esperar um documento que tem os elementos Customer, Name e Item, e que esses elementos serão organizados como no documento Source.xml a seguir.Note that the custom axis (StreamCustomerItem) is specifically written so that it expects a document that has Customer, Name, and Item elements, and that those elements will be arranged as in the following Source.xml document. Uma implementação mais robusta, no entanto, validaria o documento de origem com um XSD ou seria preparada para analisar um documento inválido.A more robust implementation, however, would either validate the source document with an XSD, or would be prepared to parse an invalid document.

Veja a seguir o documento de origem, Source.xml:The following is the source document, 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>  

O código a seguir contém um método que usa um XmlReader para transmitir o XML de origem.The following code contains a method that uses an XmlReader to stream the source XML. Ele usa XStreamingElement para transmitir o novo XML.It uses XStreamingElement to stream the new 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"));  
}  
Iterator Function StreamCustomerItem(uri As String) As IEnumerable(Of XElement)  

    Dim name As XElement = Nothing  
    Dim item As XElement = Nothing  

    Dim reader As XmlReader = XmlReader.Create(uri)  
    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 And reader.Name = "Customer") Then  
            While (reader.Read())  
                ' Move to Name element  
                If (reader.NodeType = XmlNodeType.Element And reader.Name = "Name") Then  
                    name = CType(XElement.ReadFrom(reader), XElement)  
                    Exit While  
                End If  
            End While  

            ' Loop through Item elements  
            While (reader.Read())  
                If (reader.NodeType = XmlNodeType.EndElement) Then  
                    Exit While  
                End If  

                If (reader.NodeType = XmlNodeType.Element And reader.Name = "Item") Then  
                    item = CType(XElement.ReadFrom(reader), XElement)  
                    If (Not (item Is Nothing)) Then  
                        Dim tempRoot = New XElement("Root",  
                            New XElement(name)  
                        )  
                        tempRoot.Add(item)  
                        Yield item  
                     End If  
                End If  
            End While  
        End If  
     End While  
    reader.Close()  
End Function  

Sub Main()  
    Dim root As New XStreamingElement("Root",  
        From el In StreamCustomerItem("c:\trash\Source.xml")  
        Select New XElement("Item",  
            New XElement("Customer", CStr(el.Parent.Element("Name"))),  
            New XElement(el.Element("Key"))))  
    root.Save("c:\trash\Test.xml")  
    Console.WriteLine(System.IO.File.ReadAllText("c:\trash\Test.xml"))  
End Sub  

Esse exemplo gera a saída a seguir:This example produces the following output:

<?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>  

Comentários

Essa classe permite que você crie uma árvore XML que dá suporte à saída de streaming adiada.This class allows you to create an XML tree that supports deferred streaming output. Você usa essa classe para criar uma árvore XML de maneira muito semelhante à criação de uma árvore XML usando XElement .You use this class to create an XML tree in a very similar fashion to creating an XML tree using XElement. No entanto, há uma diferença fundamental.However, there is a fundamental difference. Quando você usa uma consulta LINQ para especificar o conteúdo ao criar uma árvore XML usando XElement , a variável de consulta é iterada no momento da construção da árvore XML e os resultados da consulta são adicionados à árvore XML.When you use a LINQ query to specify content when creating an XML tree using XElement, the query variable is iterated at the time of construction of the XML tree, and the results of the query are added to the XML tree. Por outro lado, quando você cria uma árvore XML usando XStreamingElement , uma referência à variável de consulta é armazenada na árvore XML sem ser iterada.In contrast, when you create an XML tree using XStreamingElement, a reference to the query variable is stored in the XML tree without being iterated. As consultas são iteradas apenas na serialização.Queries are iterated only upon serialization. Isso permite que você crie árvores XML maiores mantendo uma superfície de memória menor.This allows you to create larger XML trees while maintaining a smaller memory footprint.

Se você estiver transmitindo de uma fonte de entrada, como um arquivo de texto, poderá ler um arquivo de texto muito grande e gerar um documento XML muito grande mantendo um pequeno volume de memória.If you are streaming from an input source, such as a text file, then you can read a very large text file, and generate a very large XML document while maintaining a small memory footprint.

Outro cenário é que você tem uma árvore XML grande que foi carregada na memória e deseja criar uma versão transformada do documento.Another scenario is that you have a large XML tree that has been loaded into memory, and you want to create a transformed version of the document. Se você criar um novo documento usando XElement , terá duas árvores XML grandes na memória após a conclusão da transformação.If you create a new document using XElement, then you will have two large XML trees in memory upon completion of the transformation. No entanto, se você criar a nova árvore XML usando XStreamingElement , seu conjunto de trabalho será efetivamente cortado pela metade.However, if you create the new XML tree using XStreamingElement, then your working set will be effectively cut in half.

Observe que, ao depurar um programa que usa XStreamingElement , a exibição do valor de um objeto faz com que seu ToString método seja chamado.Note that when debugging a program that uses XStreamingElement, displaying the value of an object causes its ToString method to be called. Isso faz com que o XML seja serializado.This causes the XML to be serialized. Se a semântica da consulta do seu elemento de streaming for de tal forma que o elemento de streaming só possa ser transmitido uma vez, isso poderá causar um comportamento indesejável na sua experiência de depuração.If the semantics of your streaming element query are such that the streaming element can only be streamed once, this may cause undesirable behavior in your debugging experience.

Construtores

XStreamingElement(XName)

Inicializa uma nova instância da classe XElement do XName especificado.Initializes a new instance of the XElement class from the specified XName.

XStreamingElement(XName, Object)

Inicializa uma nova instância da classe XStreamingElement com o nome e conteúdo especificados.Initializes a new instance of the XStreamingElement class with the specified name and content.

XStreamingElement(XName, Object[])

Inicializa uma nova instância da classe XStreamingElement com o nome e conteúdo especificados.Initializes a new instance of the XStreamingElement class with the specified name and content.

Propriedades

Name

Obtém ou define o nome deste elemento de streaming.Gets or sets the name of this streaming element.

Métodos

Add(Object)

Adiciona o conteúdo especificado como filhos deste XStreamingElement.Adds the specified content as children to this XStreamingElement.

Add(Object[])

Adiciona o conteúdo especificado como filhos deste XStreamingElement.Adds the specified content as children to this XStreamingElement.

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(Herdado de Object)
GetHashCode()

Serve como a função de hash padrão.Serves as the default hash function.

(Herdado de Object)
GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Herdado de Object)
MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Herdado de Object)
Save(Stream)

Gera este XStreamingElement para o Stream especificado.Outputs this XStreamingElement to the specified Stream.

Save(Stream, SaveOptions)

Gera esse XStreamingElement para o Stream especificado, com a opção de especificar o comportamento de formatação.Outputs this XStreamingElement to the specified Stream, optionally specifying formatting behavior.

Save(String)

Serialize este elemento de streaming para um arquivo.Serialize this streaming element to a file.

Save(String, SaveOptions)

Serialize este elemento de streaming em um arquivo, se desejar desabilitar a formatação.Serialize this streaming element to a file, optionally disabling formatting.

Save(TextWriter)

Serialize este elemento de streaming para um TextWriter.Serialize this streaming element to a TextWriter.

Save(TextWriter, SaveOptions)

Serializar este elemento de streaming para um TextWriter, se desejar desabilitar a formatação.Serialize this streaming element to a TextWriter, optionally disabling formatting.

Save(XmlWriter)

Serialize este elemento de streaming para um XmlWriter.Serialize this streaming element to an XmlWriter.

ToString()

Retorna o XML formatado (recuado) para este elemento de streaming.Returns the formatted (indented) XML for this streaming element.

ToString(SaveOptions)

Retorna o XML para este elemento de streaming, se desejar desabilitar a formatação.Returns the XML for this streaming element, optionally disabling formatting.

WriteTo(XmlWriter)

Grava este elemento de streaming em um XmlWriter.Writes this streaming element to an XmlWriter.

Aplica-se a