XStreamingElement Třída

Definice

Reprezentuje prvky ve stromu XML, které podporují odložený výstup streamování.Represents elements in an XML tree that supports deferred streaming output.

public ref class XStreamingElement
public class XStreamingElement
type XStreamingElement = class
Public Class XStreamingElement
Dědičnost
XStreamingElement

Příklady

Následující příklad nejprve vytvoří zdrojový strom XML.The following example first creates a source XML tree. Pak vytvoří transformaci zdrojového stromu XML pomocí XElement .It then creates a transform of the source XML tree using XElement. Tato transformace vytvoří nový strom v paměti.This transform creates a new tree in memory. Pak vytvoří transformaci zdrojového stromu XML pomocí XStreamingElement .It then creates a transform of the source XML tree using XStreamingElement. Tato transformace nespustí dotaz, dokud není do konzoly serializován transformovaný strom.This transform doesn't execute the query until the transformed tree is serialized to the console. Využití paměti je menší.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)  

Tento příklad vytvoří následující výstup: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>  

Jedním z přístupů ke zpracování textového souboru je zápis metody rozšíření, která vytvoří datový soubor v jednom okamžiku pomocí yield return konstrukce.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. Potom můžete napsat dotaz LINQ, který zpracovává textový soubor opožděným odloženým způsobem.You then can write a LINQ query that processes the text file in a lazy deferred fashion. Pokud potom použijete XStreamingElement Výstup ke streamování, můžete vytvořit transformaci z textového souboru do formátu XML, který používá minimální množství paměti bez ohledu na velikost zdrojového textového souboru.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.

Následující textový soubor, People.txt, je zdrojem tohoto příkladu.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  

Následující kód obsahuje metodu rozšíření, která streamuje řádky textového souboru v odvoditelné podobě.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  

Tento příklad vytvoří následující výstup: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>  

Někdy je nutné transformovat velké soubory XML a napsat aplikaci tak, aby paměťové nároky aplikace byly předvídatelné.Sometimes you have to transform large XML files, and write your application so that the memory footprint of the application is predictable. Pokud se pokusíte naplnit strom XML s velmi velkým souborem XML, využití paměti bude úměrné velikosti souboru (to znamená nadměrné).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). Proto byste měli místo toho použít metodu streamování.Therefore, you should use a streaming technique instead.

Některé standardní operátory pro dotazování, jako OrderBy je například iterace zdroje, shromáždění všech dat, jejich řazení a nakonec vydávají první položku v sekvenci.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. Všimněte si, že pokud použijete operátor dotazu, který materializuje svůj zdroj před tím, než zadáte první položku, nebudete si u své aplikace uchovávat malý objem paměti.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.

I v případě, že použijete techniku popsanou v tématu, pokud se pokusíte sestavit strom XML obsahující transformovaný dokument, využití paměti může být příliš Skvělé.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.

Následující příklad je sestaven na příkladu v tématu jak streamovat fragmenty XML s přístupem k informacím záhlaví.The following example builds on the example in How to stream XML fragments with access to header information.

V tomto příkladu se používá odložené možnosti spuštění XStreamingElement pro streamování výstupu.This example uses the deferred execution capabilities of XStreamingElement to stream the output.

Všimněte si, že vlastní osa ( StreamCustomerItem ) je specificky napsána tak, že očekává dokument, který obsahuje Customer Name prvky, a a Item že tyto prvky budou uspořádány jako v následujícím dokumentu Source.xml.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. Robustnější implementace však buď ověří zdrojový dokument s XSD, nebo by bylo připraveno analyzovat neplatný dokument.A more robust implementation, however, would either validate the source document with an XSD, or would be prepared to parse an invalid document.

Následuje zdrojový dokument 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>  

Následující kód obsahuje metodu, která používá XmlReader ke streamování zdrojového kódu XML.The following code contains a method that uses an XmlReader to stream the source XML. Používá XStreamingElement se ke streamování nového 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  

Tento příklad vytvoří následující výstup: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>  

Poznámky

Tato třída umožňuje vytvořit strom XML, který podporuje odložený výstup streamování.This class allows you to create an XML tree that supports deferred streaming output. Tuto třídu použijete k vytvoření stromu XML podobným způsobem pro vytvoření stromu XML pomocí XElement .You use this class to create an XML tree in a very similar fashion to creating an XML tree using XElement. Existuje však zásadní rozdíl.However, there is a fundamental difference. Použijete-li dotaz LINQ k určení obsahu při vytváření stromu XML pomocí XElement , je proměnná dotazu iterovaná v době konstrukce stromu XML a výsledky dotazu jsou přidány do stromu 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. Naproti tomu při vytváření stromu XML pomocí XStreamingElement , odkaz na proměnnou dotazu je uložen ve stromu XML bez iterace.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. Dotazy jsou iterované pouze při serializaci.Queries are iterated only upon serialization. Díky tomu můžete vytvořit větší stromy XML a zároveň zachovat menší nároky na paměť.This allows you to create larger XML trees while maintaining a smaller memory footprint.

Pokud streamuje ze vstupního zdroje, jako je textový soubor, můžete si přečíst velmi velký textový soubor a při zachování malých objemů paměti vygenerovat velmi velký dokument XML.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.

Dalším scénářem je, že máte velký strom XML, který byl načten do paměti, a chcete vytvořit transformované verze dokumentu.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. Pokud vytvoříte nový dokument pomocí XElement , budete mít po dokončení transformace dvě velké stromy XML v paměti.If you create a new document using XElement, then you will have two large XML trees in memory upon completion of the transformation. Pokud však vytvoříte nový strom XML pomocí XStreamingElement , bude vaše pracovní sada efektivně vydělena na polovinu.However, if you create the new XML tree using XStreamingElement, then your working set will be effectively cut in half.

Všimněte si, že při ladění programu, který používá XStreamingElement , se zobrazí hodnota objektu, což způsobí ToString volání metody.Note that when debugging a program that uses XStreamingElement, displaying the value of an object causes its ToString method to be called. Tím dojde k serializaci kódu XML.This causes the XML to be serialized. Pokud jsou sémantika dotazu na prvky streamování tak, že element streamování může být jenom jednou streamované, může to způsobit nežádoucí chování v prostředí ladění.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.

Konstruktory

XStreamingElement(XName)

Inicializuje novou instanci XElement třídy ze zadaného XName .Initializes a new instance of the XElement class from the specified XName.

XStreamingElement(XName, Object)

Inicializuje novou instanci XStreamingElement třídy se zadaným názvem a obsahem.Initializes a new instance of the XStreamingElement class with the specified name and content.

XStreamingElement(XName, Object[])

Inicializuje novou instanci XStreamingElement třídy se zadaným názvem a obsahem.Initializes a new instance of the XStreamingElement class with the specified name and content.

Vlastnosti

Name

Získá nebo nastaví název tohoto streamového elementu.Gets or sets the name of this streaming element.

Metody

Add(Object)

Přidá zadaný obsah jako podřízené objekty XStreamingElement .Adds the specified content as children to this XStreamingElement.

Add(Object[])

Přidá zadaný obsah jako podřízené objekty XStreamingElement .Adds the specified content as children to this XStreamingElement.

Equals(Object)

Určí, zda se zadaný objekt rovná aktuálnímu objektu.Determines whether the specified object is equal to the current object.

(Zděděno od Object)
GetHashCode()

Slouží jako výchozí funkce hash.Serves as the default hash function.

(Zděděno od Object)
GetType()

Získá Type aktuální instanci.Gets the Type of the current instance.

(Zděděno od Object)
MemberwiseClone()

Vytvoří kopii aktuálního seznamu Object .Creates a shallow copy of the current Object.

(Zděděno od Object)
Save(Stream)

Vytvoří výstup XStreamingElement do určeného Stream .Outputs this XStreamingElement to the specified Stream.

Save(Stream, SaveOptions)

Provede výstup XStreamingElement do zadaného Stream nastavení, volitelně určení chování formátování.Outputs this XStreamingElement to the specified Stream, optionally specifying formatting behavior.

Save(String)

Serializace tohoto elementu streamování do souboruSerialize this streaming element to a file.

Save(String, SaveOptions)

Serializace tohoto elementu streamování do souboru, volitelně zakázání formátováníSerialize this streaming element to a file, optionally disabling formatting.

Save(TextWriter)

Serializovat tento prvek streamování na TextWriter .Serialize this streaming element to a TextWriter.

Save(TextWriter, SaveOptions)

Serializovat tento prvek streamování na TextWriter , volitelně zakázat formátování.Serialize this streaming element to a TextWriter, optionally disabling formatting.

Save(XmlWriter)

Serializovat tento prvek streamování na XmlWriter .Serialize this streaming element to an XmlWriter.

ToString()

Vrátí formátovaný (odsazený) kód XML pro tento element streamování.Returns the formatted (indented) XML for this streaming element.

ToString(SaveOptions)

Vrátí XML pro tento element streamování, volitelně zakáže formátování.Returns the XML for this streaming element, optionally disabling formatting.

WriteTo(XmlWriter)

Zapíše tento prvek streamování do XmlWriter .Writes this streaming element to an XmlWriter.

Platí pro