XStreamingElement 클래스

정의

XML 트리에서 지연된 스트리밍 출력을 지원하는 요소를 나타냅니다.Represents elements in an XML tree that supports deferred streaming output.

public ref class XStreamingElement
public class XStreamingElement
type XStreamingElement = class
Public Class XStreamingElement
상속
XStreamingElement

예제

다음 예제에서는 먼저 소스 XML 트리를 만듭니다.The following example first creates a source XML tree. 그런 다음 사용 하 여 원본의 XML 트리 변환 만듭니다 XElement합니다.It then creates a transform of the source XML tree using XElement. 이 변환은 메모리에 새 트리를 만듭니다.This transform creates a new tree in memory. 그런 다음 사용 하 여 원본의 XML 트리 변환 만듭니다 XStreamingElement합니다.It then creates a transform of the source XML tree using XStreamingElement. 이 변환은 변환된 된 트리를 콘솔에 serialize 될 때까지 쿼리를 실행 하지 않습니다.This transform doesn't execute the query until the transformed tree is serialized to the console. 메모리 사용량이 작습니다.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)  

이 예제는 다음과 같은 출력을 생성합니다.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>  

텍스트 파일을 처리하는 한 가지 방법은 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. 그런 다음 지연된 방식으로 텍스트 파일을 처리하는 LINQ 쿼리를 작성할 수 있습니다.You then can write a LINQ query that processes the text file in a lazy deferred fashion. 다음 사용 하는 경우는 XStreamingElement 스트림 출력으로 다음에서 만들 수 있습니다 변환 텍스트 파일을 소스 텍스트 파일의 크기에 관계 없이 메모리의 최소 크기를 사용 하는 XML입니다.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.

아래에 있는 People.txt 텍스트 파일은 이 예제의 소스입니다.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  

다음 코드에는 지연된 방식으로 텍스트 파일의 줄을 스트림하는 확장 메서드가 포함되어 있습니다.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  

이 예제는 다음과 같은 출력을 생성합니다.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>  

큰 XML 파일을 변환하고 애플리케이션의 메모리 사용 공간이 예상 가능하도록 애플리케이션을 작성해야 하는 경우가 있습니다.Sometimes you have to transform large XML files, and write your application so that the memory footprint of the application is predictable. XML 트리를 매우 큰 XML 파일로 채우려는 경우 메모리 사용은 파일 크기에 비례하므로 지나치게 증가하게 됩니다.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). 따라서 스트리밍 기법을 대신 사용해야 합니다.Therefore, you should use a streaming technique instead.

OrderBy와 같은 특정 표준 쿼리 연산자는 자신의 소스를 반복하고 모든 데이터를 수집하여 정렬한 다음 시퀀스의 첫 번째 항목을 최종적으로 생성합니다.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. 첫 번째 항목을 반환하기 전에 소스를 유형화하는 쿼리 연산자를 사용하는 경우 애플리케이션에 대한 작은 메모리 사용 공간이 유지되지 않습니다.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.

변환 된 문서가 포함 된 XML 트리를 조합 하면에서 설명 하는 기법을 사용 하는 경우에 메모리 사용량이 너무 수 있습니다.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.

다음 예제는 방법: 헤더 정보에 대 한 액세스 권한이 있는 XML 조각을 스트리밍합니다.The following example builds on the example in How to: Stream XML Fragments with Access to Header Information.

이 예제에서는 XStreamingElement의 지연된 실행 기능을 사용하여 출력을 스트림합니다.This example uses the deferred execution capabilities of XStreamingElement to stream the output.

사용자 지정 축(StreamCustomerItem)은 문서에 Customer, NameItem 요소가 있고 이러한 요소가 다음 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. 그러나 더욱 강력한 구현은 XSD를 사용하여 소스 문서의 유효성을 검사하거나, 잘못된 문서의 구문을 분석할 준비가 되어 있습니다.A more robust implementation, however, would either validate the source document with an XSD, or would be prepared to parse an invalid document.

다음은 소스 문서인 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>  

다음 코드에 사용 하는 메서드는 XmlReader 소스 XML을 스트림 하 합니다.The following code contains a method that uses an XmlReader to stream the source XML. 사용 하 여 XStreamingElement 에 새 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  

이 예제는 다음과 같은 출력을 생성합니다.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>  

설명

이 클래스를 사용 하면 지연 된 스트리밍 출력을 지 원하는 XML 트리를 만들 수 있습니다.This class allows you to create an XML tree that supports deferred streaming output. 이 클래스를 사용 하 여 사용 하 여 XML 트리 만들기는 매우 비슷한 방식으로 XML 트리를 만들려는 XElement합니다.You use this class to create an XML tree in a very similar fashion to creating an XML tree using XElement. 그러나 근본적인 차이가 있습니다.However, there is a fundamental difference. LINQ 쿼리를 사용 하 여 트리 XML을 만들 때 콘텐츠를 지정 하려면 사용 하는 경우 XElementXML 트리 생성 당시에는 쿼리 변수가 반복 되 고 쿼리의 결과 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. 이와 대조적으로 만들 때 사용 하 여 XML 트리를 XStreamingElement, 반복 되지 않고 XML 트리에서 쿼리 변수에 대 한 참조 저장 됩니다.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. 쿼리는 직렬화 될 경우에 반복 됩니다.Queries are iterated only upon serialization. 이 옵션을 사용 하면 작은 메모리 사용 공간을 유지 하는 동안 더 큰 XML 트리를 만들 수 있습니다.This allows you to create larger XML trees while maintaining a smaller memory footprint.

텍스트 파일과 같은 입력된 원본에서 스트리밍하는 경우 매우 큰 텍스트 파일 읽기 및 작은 메모리 사용 공간을 유지 하면서 매우 큰 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.

다른 시나리오는 대형 XML 트리를 메모리에 로드 된 있는 변환 된 버전의 문서를 만들려고 할 수 있다는 것입니다.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. 사용 하 여 새 문서를 만드는 경우 XElement에 변환이 완료 될 때 메모리에 두 개의 대형 XML 트리를 사용 해야 합니다.If you create a new document using XElement, then you will have two large XML trees in memory upon completion of the transformation. 그러나 사용 하 여 새 XML 트리를 만드는 경우 XStreamingElement, 다음 절반 작업 집합을 효과적으로 제거 될 예정입니다.However, if you create the new XML tree using XStreamingElement, then your working set will be effectively cut in half.

사용 하는 프로그램을 디버깅 하는 경우 사용자에 게 유의 XStreamingElement, 개체의 값을 표시 하면 해당 ToString 호출 될 메서드입니다.Note that when debugging a program that uses XStreamingElement, displaying the value of an object causes its ToString method to be called. 이렇게 하면 XML을 serialize 합니다.This causes the XML to be serialized. 스트리밍 요소 쿼리 의미 체계는 스트리밍 요소를 한 번만 스트림 수 있는 경우에 디버깅 환경에서 바람직하지 않은 동작이 발생할 수 있습니다이 있습니다.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.

생성자

XStreamingElement(XName)

지정된 XName에서 XElement 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the XElement class from the specified XName.

XStreamingElement(XName, Object)

지정된 이름 및 콘텐츠를 사용하여 XStreamingElement 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the XStreamingElement class with the specified name and content.

XStreamingElement(XName, Object[])

지정된 이름 및 콘텐츠를 사용하여 XStreamingElement 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the XStreamingElement class with the specified name and content.

속성

Name

이 스트리밍 요소의 이름을 가져오거나 설정합니다.Gets or sets the name of this streaming element.

메서드

Add(Object)

지정된 콘텐츠를 이 XStreamingElement에 자식으로 추가합니다.Adds the specified content as children to this XStreamingElement.

Add(Object[])

지정된 콘텐츠를 이 XStreamingElement에 자식으로 추가합니다.Adds the specified content as children to this XStreamingElement.

Equals(Object)

지정한 개체와 현재 개체가 같은지 여부를 확인합니다.Determines whether the specified object is equal to the current object.

(다음에서 상속됨 Object)
GetHashCode()

기본 해시 함수로 작동합니다.Serves as the default hash function.

(다음에서 상속됨 Object)
GetType()

현재 인스턴스의 Type을 가져옵니다.Gets the Type of the current instance.

(다음에서 상속됨 Object)
MemberwiseClone()

현재 Object의 단순 복사본을 만듭니다.Creates a shallow copy of the current Object.

(다음에서 상속됨 Object)
Save(Stream)

XStreamingElement를 지정된 Stream에 출력합니다.Outputs this XStreamingElement to the specified Stream.

Save(Stream, SaveOptions)

XStreamingElement를 지정된 Stream에 출력하고 선택적으로 형식 지정 동작을 지정합니다.Outputs this XStreamingElement to the specified Stream, optionally specifying formatting behavior.

Save(String)

이 스트리밍 요소를 파일로 serialize합니다.Serialize this streaming element to a file.

Save(String, SaveOptions)

이 스트리밍 요소를 파일로 serialize하고, 선택적으로 서식 지정을 해제합니다.Serialize this streaming element to a file, optionally disabling formatting.

Save(TextWriter)

이 스트리밍 요소를 TextWriter로 serialize합니다.Serialize this streaming element to a TextWriter.

Save(TextWriter, SaveOptions)

이 스트리밍 요소를 TextWriter로 serialize하고, 선택적으로 서식 지정을 해제합니다.Serialize this streaming element to a TextWriter, optionally disabling formatting.

Save(XmlWriter)

이 스트리밍 요소를 XmlWriter로 serialize합니다.Serialize this streaming element to an XmlWriter.

ToString()

이 스트리밍 요소의 형식 지정(들여쓰기)된 XML을 반환합니다.Returns the formatted (indented) XML for this streaming element.

ToString(SaveOptions)

이 스트리밍 요소의 XML을 반환하고, 선택적으로 서식 지정을 해제합니다.Returns the XML for this streaming element, optionally disabling formatting.

WriteTo(XmlWriter)

이 스트리밍 요소를 XmlWriter에 씁니다.Writes this streaming element to an XmlWriter.

적용 대상

추가 정보