XStreamingElement XStreamingElement XStreamingElement XStreamingElement Class

Definizione

Rappresenta elementi in una struttura ad albero XML che supporta l'output del flusso differito.Represents elements in an XML tree that supports deferred streaming output.

public ref class XStreamingElement
public class XStreamingElement
type XStreamingElement = class
Public Class XStreamingElement
Ereditarietà
XStreamingElementXStreamingElementXStreamingElementXStreamingElement

Esempi

L'esempio seguente crea innanzitutto un albero XML di origine.The following example first creates a source XML tree. Crea quindi una trasformazione dell'origine XML albero utilizzando XElement.It then creates a transform of the source XML tree using XElement. Questa trasformazione consente di creare un nuovo albero in memoria.This transform creates a new tree in memory. Crea quindi una trasformazione dell'origine XML albero utilizzando XStreamingElement.It then creates a transform of the source XML tree using XStreamingElement. Questa trasformazione non esegue la query fino a quando l'albero trasformato viene serializzato nella console.This transform doesn't execute the query until the transformed tree is serialized to the console. L'utilizzo della memoria è inferiore.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)  

Questo esempio produce il seguente output: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>  

Uno degli approcci disponibili per l'elaborazione di un file di testo consiste nello scrivere un metodo di estensione che genera un flusso del file di testo, una riga alla volta, tramite il costrutto 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. È quindi possibile scrivere una query LINQ che elabora il file di testo in modo posticipato lazy.You then can write a LINQ query that processes the text file in a lazy deferred fashion. Se si usa quindi il XStreamingElement al flusso di output, è possibile creare una trasformazione del file di testo in formato XML che utilizza una quantità minima di memoria, indipendentemente dalle dimensioni del file di testo di origine.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.

Il file di testo seguente, People.txt, è l'origine di questo esempio.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  

Nel codice seguente è contenuto un metodo di estensione che genera il flusso delle righe del file di testo in modo posticipato.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  

Questo esempio produce il seguente output: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>  

A volte è necessario trasformare file XML di grandi dimensioni e scrivere l'applicazione in modo tale che il footprint di memoria dell'applicazione sia prevedibile.Sometimes you have to transform large XML files, and write your application so that the memory footprint of the application is predictable. Se si tenta di popolare un albero XML con un file XML molto grande, l'uso della memoria sarà proporzionale alla dimensione del file (ovvero, eccessivo).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). Pertanto, è necessario usare una tecnica di flusso in sostituzione.Therefore, you should use a streaming technique instead.

Determinati operatori di query standard, ad esempio OrderBy, scorrono l'origine, raccolgono tutti i dati, li ordinano e infine restituiscono il primo elemento nella sequenza.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. Si noti che se si usa un operatore di query che materializza l'origine prima di restituire il primo elemento, non verrà mantenuto un footprint di memoria ridotto per l'applicazione.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.

Anche se si usa la tecnica descritta in, se si tenta di assemblare un albero XML che contiene il documento trasformato, utilizzo della memoria potrebbe essere troppo elevato.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.

L'esempio seguente si basa sull'esempio riportato in Procedura: Stream frammenti XML con accesso a informazioni di intestazione.The following example builds on the example in How to: Stream XML Fragments with Access to Header Information.

In questo esempio vengono usate le funzionalità di esecuzione posticipata di XStreamingElement per generare il flusso di output.This example uses the deferred execution capabilities of XStreamingElement to stream the output.

Si noti che il metodo dell'asse personalizzato (StreamCustomerItem) è stato scritto in modo tale da prevedere un documento contenente elementi Customer, Name e Item, disposti come nel documento Source.xml seguente.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. Tuttavia, un'implementazione più affidabile convaliderebbe il documento di origine con uno schema XSD oppure verrebbe preparata per analizzare un documento non valido.A more robust implementation, however, would either validate the source document with an XSD, or would be prepared to parse an invalid document.

Il documento seguente, Source.xml, è il documento di origine: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>  

Il codice seguente contiene un metodo che usa un XmlReader il flusso XML di origine.The following code contains a method that uses an XmlReader to stream the source XML. Usa XStreamingElement per trasmettere il nuovo codice 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  

Questo esempio produce il seguente output: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>  

Commenti

Questa classe consente di creare un albero XML che supporta l'output del flusso posticipato.This class allows you to create an XML tree that supports deferred streaming output. Utilizzare questa classe per creare un albero XML in modo molto simile alla creazione di un albero XML usando XElement.You use this class to create an XML tree in a very similar fashion to creating an XML tree using XElement. Tuttavia, vi è una differenza fondamentale.However, there is a fundamental difference. Quando si utilizza una query LINQ per specificare il contenuto durante la creazione di un file XML della struttura ad albero usando XElement, la variabile di query viene iterata al momento della costruzione dell'albero XML e i risultati della query vengono aggiunti all'albero 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. Al contrario, quando si crea un albero XML usando XStreamingElement, un riferimento alla variabile di query viene archiviato nell'albero XML senza in fase di iterazione.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. Le query vengono Iterate solo durante la serializzazione.Queries are iterated only upon serialization. In questo modo è possibile creare alberi XML più grandi mantenendo un footprint di memoria più piccolo.This allows you to create larger XML trees while maintaining a smaller memory footprint.

Se si utilizza il flusso da un'origine di input, ad esempio un file di testo, quindi è possibile leggere un file di testo di dimensioni molto grandi e generare un documento XML di dimensioni molto grande mantenendo un footprint di memoria di piccole dimensioni.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.

Un altro scenario è che si dispone di un albero XML di grandi dimensioni che è stato caricato in memoria e si desidera creare una versione trasformata del 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 si crea un nuovo documento usando XElement, avrai due strutture ad albero XML di grandi dimensioni in memoria dopo il completamento della trasformazione.If you create a new document using XElement, then you will have two large XML trees in memory upon completion of the transformation. Tuttavia, se si crea il nuovo albero XML usando XStreamingElement, quindi verrà eliminato in modo efficace il working set a metà.However, if you create the new XML tree using XStreamingElement, then your working set will be effectively cut in half.

Si noti che durante il debug di un programma che usa XStreamingElement, fa in modo che la visualizzazione del valore di un oggetto relativo ToString metodo da chiamare.Note that when debugging a program that uses XStreamingElement, displaying the value of an object causes its ToString method to be called. In questo modo il codice XML da serializzare.This causes the XML to be serialized. Se la semantica della query elemento di streaming in modo che l'elemento di flusso può essere trasmesso solo una volta, ciò potrebbe causare un comportamento indesiderato nell'esperienza di debug.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.

Costruttori

XStreamingElement(XName) XStreamingElement(XName) XStreamingElement(XName) XStreamingElement(XName)

Inizializza una nuova istanza della classe XElement dall'oggetto XName specificato.Initializes a new instance of the XElement class from the specified XName.

XStreamingElement(XName, Object) XStreamingElement(XName, Object) XStreamingElement(XName, Object) XStreamingElement(XName, Object)

Inizializza una nuova istanza della classe XStreamingElement con un nome e un contenuto specificato.Initializes a new instance of the XStreamingElement class with the specified name and content.

XStreamingElement(XName, Object[]) XStreamingElement(XName, Object[]) XStreamingElement(XName, Object[]) XStreamingElement(XName, Object[])

Inizializza una nuova istanza della classe XStreamingElement con un nome e un contenuto specificato.Initializes a new instance of the XStreamingElement class with the specified name and content.

Proprietà

Name Name Name Name

Ottiene o imposta il nome dell'elemento di flusso.Gets or sets the name of this streaming element.

Metodi

Add(Object) Add(Object) Add(Object) Add(Object)

Aggiunge il contenuto specificato come figlio a XStreamingElement.Adds the specified content as children to this XStreamingElement.

Add(Object[]) Add(Object[]) Add(Object[]) Add(Object[])

Aggiunge il contenuto specificato come figlio a XStreamingElement.Adds the specified content as children to this XStreamingElement.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Inherited from Object)
Save(Stream) Save(Stream) Save(Stream) Save(Stream)

Genera questo oggetto XStreamingElement nell'oggetto Stream specificato.Outputs this XStreamingElement to the specified Stream.

Save(Stream, SaveOptions) Save(Stream, SaveOptions) Save(Stream, SaveOptions) Save(Stream, SaveOptions)

Restituisce questo oggetto XStreamingElement all'oggetto Stream specificato, indicando facoltativamente il comportamento della formattazione.Outputs this XStreamingElement to the specified Stream, optionally specifying formatting behavior.

Save(String) Save(String) Save(String) Save(String)

Serializzare questo elemento di flusso in un file.Serialize this streaming element to a file.

Save(String, SaveOptions) Save(String, SaveOptions) Save(String, SaveOptions) Save(String, SaveOptions)

Serializzare questo elemento di flusso in un file, disabilitando facoltativamente la formattazione.Serialize this streaming element to a file, optionally disabling formatting.

Save(TextWriter) Save(TextWriter) Save(TextWriter) Save(TextWriter)

Serializzare questo elemento di flusso in un TextWriter.Serialize this streaming element to a TextWriter.

Save(TextWriter, SaveOptions) Save(TextWriter, SaveOptions) Save(TextWriter, SaveOptions) Save(TextWriter, SaveOptions)

Serializzare questo elemento di flusso in un TextWriter, disabilitando facoltativamente la formattazione.Serialize this streaming element to a TextWriter, optionally disabling formatting.

Save(XmlWriter) Save(XmlWriter) Save(XmlWriter) Save(XmlWriter)

Serializzare questo elemento di flusso in un XmlWriter.Serialize this streaming element to an XmlWriter.

ToString() ToString() ToString() ToString()

Restituisce il codice XML formattato (con rientro) per questo elemento di flusso.Returns the formatted (indented) XML for this streaming element.

ToString(SaveOptions) ToString(SaveOptions) ToString(SaveOptions) ToString(SaveOptions)

Restituisce il codice XML per questo elemento di flusso, disabilitando facoltativamente la formattazione.Returns the XML for this streaming element, optionally disabling formatting.

WriteTo(XmlWriter) WriteTo(XmlWriter) WriteTo(XmlWriter) WriteTo(XmlWriter)

Scrive questo elemento di flusso in un XmlWriter.Writes this streaming element to an XmlWriter.

Si applica a

Vedi anche