XStreamingElement Klasse

Definition

Stellt Elemente in einer XML-Struktur dar, die verzögerte Streamingausgabe unterstützt.Represents elements in an XML tree that supports deferred streaming output.

public ref class XStreamingElement
public class XStreamingElement
type XStreamingElement = class
Public Class XStreamingElement
Vererbung
XStreamingElement

Beispiele

Im folgenden Beispiel wird zunächst eine Quell-XML-Struktur erstellt.The following example first creates a source XML tree. Anschließend wird mithilfe XElementvon eine Transformation der Quell-XML-Struktur erstellt.It then creates a transform of the source XML tree using XElement. Diese Transformation erstellt eine neue Struktur im Arbeitsspeicher.This transform creates a new tree in memory. Anschließend wird mithilfe XStreamingElementvon eine Transformation der Quell-XML-Struktur erstellt.It then creates a transform of the source XML tree using XStreamingElement. Diese Transformation führt die Abfrage erst aus, nachdem die transformierte Struktur in die Konsole serialisiert wurde.This transform doesn't execute the query until the transformed tree is serialized to the console. Die Speicherauslastung ist geringer.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)  

Dieses Beispiel erzeugt die folgende Ausgabe: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>  

Ein Ansatz für die Verarbeitung einer Textdatei besteht darin, eine Erweiterungsmethode zu schreiben, die die Textdatei mit dem yield return-Konstrukt zeilenweise streamt.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. Anschließend können Sie eine LINQ-Abfrage schreiben, die die Textdatei verzögert verarbeitet.You then can write a LINQ query that processes the text file in a lazy deferred fashion. Wenn Sie dann die Ausgabe XStreamingElement zum Streamen der Ausgabe verwenden, können Sie eine Transformation aus der Textdatei in XML erstellen, die eine minimale Menge an Arbeitsspeicher verwendet, unabhängig von der Größe der Quell Textdatei.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.

In diesem Beispiel wird die folgende Textdatei, People.txt, als Quelldatei verwendet: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  

Der folgende Code enthält eine Erweiterungsmethode, die die Zeilen der Textdatei verzögert streamt.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  

Dieses Beispiel erzeugt die folgende Ausgabe: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>  

Es kann vorkommen, dass Sie große XML-Dateien transformieren und Ihre Anwendung so schreiben müssen, dass der Arbeitsspeicherbedarf der Anwendung vorhersehbar ist.Sometimes you have to transform large XML files, and write your application so that the memory footprint of the application is predictable. Wenn Sie versuchen, eine XML-Struktur mit einer sehr großen XML-Datei zu füllen, ändert sich Ihre Speicherbeanspruchung proportional zur Größe der Datei, also exzessiv.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). Deshalb sollten Sie stattdessen ein Streamingverfahren verwenden.Therefore, you should use a streaming technique instead.

Einige Standardabfrageoperatoren, wie OrderBy, durchlaufen ihre Quelle, erfassen alle Daten, sortieren sie und geben dann das erste Element in der Sequenz zurück.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. Beachten Sie, dass Sie bei der Verwendung eines Abfrageoperators, der seine Quelle vor der Rückgabe des ersten Elements materialisiert, keine minimale Speicherbeanspruchung für Ihre Anwendung aufrechterhalten können.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.

Auch wenn Sie das in beschriebene Verfahren verwenden, wenn Sie versuchen, eine XML-Struktur zusammenzufassen, die das transformierte Dokument enthält, kann die Speicherauslastung zu groß sein.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.

Das folgende Beispiel baut auf dem Beispiel in Vorgehensweise: Streamen von XML-Fragmenten mit Zugriff aufHeader Informationen.The following example builds on the example in How to: Stream XML Fragments with Access to Header Information.

In diesem Beispiel wird die verzögerte Ausführung von XStreamingElement verwendet, um die Ausgabe zu streamen.This example uses the deferred execution capabilities of XStreamingElement to stream the output.

Beachten Sie, dass die benutzerdefinierte Achse (StreamCustomerItem) so geschrieben ist, dass sie über ein Dokument mit Customer-Elementen, Name-Elementen und Item-Elementen verfügt. Diese Elemente werden wie im folgenden Source.xml-Dokument angeordnet.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. Eine robustere Implementierung würde jedoch entweder das Quelldokument mit einer XSD prüfen oder darauf vorbereitet sein, ein ungültiges Dokument analysieren zu können.A more robust implementation, however, would either validate the source document with an XSD, or would be prepared to parse an invalid document.

Das Quelldokument (Source.xml) sieht wie folgt aus: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>  

Der folgende Code enthält eine-Methode, die XmlReader verwendet, um die XML-Quelldatei zu streamen.The following code contains a method that uses an XmlReader to stream the source XML. Es verwendet XStreamingElement , um den neuen XML-Code zu streamen.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  

Dieses Beispiel erzeugt die folgende Ausgabe: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>  

Hinweise

Mit dieser Klasse können Sie eine XML-Struktur erstellen, die die verzögerte Streamingausgabe unterstützt.This class allows you to create an XML tree that supports deferred streaming output. Sie verwenden diese Klasse zum Erstellen einer XML-Struktur in einer sehr ähnlichen Weise wie das Erstellen einer XML XElement-Struktur mit.You use this class to create an XML tree in a very similar fashion to creating an XML tree using XElement. Es gibt jedoch einen grundlegenden Unterschied.However, there is a fundamental difference. Wenn Sie beim Erstellen einer XML-Struktur mithilfe XElementeiner LINQ-Abfrage Inhalt angeben, wird die Abfrage Variable zum Zeitpunkt der Erstellung der XML-Struktur durchlaufen, und die Ergebnisse der Abfrage werden der XML-Struktur hinzugefügt.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. Wenn Sie hingegen mithilfe von eine XML-Struktur erstellen XStreamingElement, wird ein Verweis auf die Abfrage Variable in der XML-Struktur gespeichert, ohne dass Sie durchlaufen wird.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. Abfragen werden nur bei der Serialisierung durchlaufen.Queries are iterated only upon serialization. Dies ermöglicht es Ihnen, größere XML-Strukturen zu erstellen und gleichzeitig einen geringeren Speicherbedarf zu erhalten.This allows you to create larger XML trees while maintaining a smaller memory footprint.

Wenn Sie von einer Eingabe Quelle aus streamen (z. b. einer Textdatei), können Sie eine sehr große Textdatei lesen und ein sehr großes XML-Dokument generieren, während Sie einen geringen Speicherbedarf erhalten.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.

Ein anderes Szenario besteht darin, dass Sie über eine große XML-Struktur verfügen, die in den Arbeitsspeicher geladen wurde, und Sie eine transformierte Version des Dokuments erstellen möchten.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. Wenn Sie ein neues Dokument mit XElementerstellen, verfügen Sie nach Abschluss der Transformation über zwei große XML-Strukturen im Arbeitsspeicher.If you create a new document using XElement, then you will have two large XML trees in memory upon completion of the transformation. Wenn Sie jedoch die neue XML-Struktur mit XStreamingElementerstellen, wird Ihr Workingset effektiv in der Hälfte abgeschnitten.However, if you create the new XML tree using XStreamingElement, then your working set will be effectively cut in half.

Beachten Sie, dass beim Debuggen XStreamingElementeines Programms, das verwendet, das Anzeigen des ToString Werts eines Objekts bewirkt, dass die-Methode aufgerufen wird.Note that when debugging a program that uses XStreamingElement, displaying the value of an object causes its ToString method to be called. Dies bewirkt, dass der XML-Code serialisiert wird.This causes the XML to be serialized. Wenn die Semantik Ihrer Streaming-Element-Abfrage so ist, dass das Streaming-Element nur einmal gestreamt werden kann, kann dies zu unerwünschten Verhalten in der debuggingdarstellung führen.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.

Konstruktoren

XStreamingElement(XName)

Initialisiert eine neue Instanz der XElement-Klasse mit dem angegebenen XName.Initializes a new instance of the XElement class from the specified XName.

XStreamingElement(XName, Object)

Initialisiert eine neue Instanz der XStreamingElement-Klasse mit dem angegebenen Namen und Inhalt.Initializes a new instance of the XStreamingElement class with the specified name and content.

XStreamingElement(XName, Object[])

Initialisiert eine neue Instanz der XStreamingElement-Klasse mit dem angegebenen Namen und Inhalt.Initializes a new instance of the XStreamingElement class with the specified name and content.

Eigenschaften

Name

Ruft den Namen des Streamingelements ab oder legt diesen fest.Gets or sets the name of this streaming element.

Methoden

Add(Object)

Fügt diesem XStreamingElement den angegebenen Inhalt als untergeordnetes Element hinzu.Adds the specified content as children to this XStreamingElement.

Add(Object[])

Fügt diesem XStreamingElement den angegebenen Inhalt als untergeordnetes Element hinzu.Adds the specified content as children to this XStreamingElement.

Equals(Object)

Ermittelt, ob das angegebene Objekt und das aktuelle Objekt gleich sind.Determines whether the specified object is equal to the current object.

(Geerbt von Object)
GetHashCode()

Dient als die Standard-HashfunktionServes as the default hash function.

(Geerbt von Object)
GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Geerbt von Object)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Geerbt von Object)
Save(Stream)

Gibt diesen XStreamingElement an den angegebenen Stream aus.Outputs this XStreamingElement to the specified Stream.

Save(Stream, SaveOptions)

Gibt dieses XStreamingElement zum angegebenen Stream aus und gibt Formatierungsverhalten optional an.Outputs this XStreamingElement to the specified Stream, optionally specifying formatting behavior.

Save(String)

Serialisiert dieses Streamingelement in einer Datei.Serialize this streaming element to a file.

Save(String, SaveOptions)

Serialisiert dieses Streamingelement in eine Datei, wobei optional die Formatierung deaktiviert wird.Serialize this streaming element to a file, optionally disabling formatting.

Save(TextWriter)

Serialisiert dieses Streamingelement in einen TextWriter.Serialize this streaming element to a TextWriter.

Save(TextWriter, SaveOptions)

Serialisiert dieses Streamingelement in einen TextWriter, wobei optional die Formatierung deaktiviert wird.Serialize this streaming element to a TextWriter, optionally disabling formatting.

Save(XmlWriter)

Serialisiert dieses Streamingelement in einen XmlWriter.Serialize this streaming element to an XmlWriter.

ToString()

Gibt das formatierte (eingezogene) XML für dieses Streamingelement zurück.Returns the formatted (indented) XML for this streaming element.

ToString(SaveOptions)

Gibt das XML für dieses Streamingelement zurück, wobei optional die Formatierung deaktiviert wird.Returns the XML for this streaming element, optionally disabling formatting.

WriteTo(XmlWriter)

Schreibt dieses Streamingelement in einen XmlWriter.Writes this streaming element to an XmlWriter.

Gilt für:

Siehe auch