XStreamingElement Sınıf

Tanım

Ad Alanı:: System.Xml.Linq

Bütünleştirilmiş Kodlar:: System.Xml.Linq.dll, System.Xml.XDocument.dll

Bütünleştirilmiş Kodlar:: netstandard.dll, System.Xml.XDocument.dll

Bütünleştirilmiş Kod:: System.Xml.XDocument.dll

Bütünleştirilmiş Kod:: System.Xml.Linq.dll

Bütünleştirilmiş Kod:: netstandard.dll

Kaynak:: XStreamingElement.cs

Kaynak:: XStreamingElement.cs

Kaynak:: XStreamingElement.cs

Kaynak:: XStreamingElement.cs

Kaynak:: XStreamingElement.cs

Önemli

Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.

Ertelenmiş akış çıkışını destekleyen bir XML ağacındaki öğeleri temsil eder.

public ref class XStreamingElement

public class XStreamingElement

type XStreamingElement = class

Public Class XStreamingElement

Devralma: Object
XStreamingElement

Örnekler

Aşağıdaki örnek önce bir kaynak XML ağacı oluşturur. Ardından kullanarak XElementkaynak XML ağacının bir dönüşümünü oluşturur. Bu dönüşüm bellekte yeni bir ağaç oluşturur. Ardından kullanarak XStreamingElementkaynak XML ağacının bir dönüşümünü oluşturur. Bu dönüşüm, dönüştürülen ağaç konsolda seri hale getirilene kadar sorguyu yürütmez. Bellek kullanımı daha azdır.

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)

Bu örnek aşağıdaki çıkışı oluşturur:

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

Metin dosyasını işlemeye yönelik bir yaklaşım, yapıyı kullanarak metin dosyasını bir kerede bir satır akışla aktaran bir uzantı yöntemi yazmaktır yield return . Daha sonra metin dosyasını gecikmeli bir şekilde işleyen bir LINQ sorgusu yazabilirsiniz. Çıkışı akışla aktarmak için kullanırsanız XStreamingElement , kaynak metin dosyasının boyutundan bağımsız olarak en az miktarda bellek kullanan metin dosyasından XML'ye bir dönüşüm oluşturabilirsiniz.

Aşağıdaki metin dosyası People.txt, bu örneğin kaynağıdır.

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

Aşağıdaki kod, metin dosyasının satırlarını ertelenmiş bir şekilde akışla aktaran bir uzantı yöntemi içerir.

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

Bu örnek aşağıdaki çıkışı oluşturur:

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

Bazen büyük XML dosyalarını dönüştürmeniz ve uygulamanızı yazarak uygulamanın bellek ayak izini tahmin edilebilir hale getirmeniz gerekir. Bir XML ağacını çok büyük bir XML dosyasıyla doldurmaya çalışırsanız, bellek kullanımınız dosyanın boyutuyla orantılı olur (aşırı). Bu nedenle, bunun yerine bir akış tekniği kullanmalısınız.

gibi OrderBybazı standart sorgu işleçleri kaynaklarını yineler, tüm verileri toplar, sıralar ve son olarak dizideki ilk öğeyi verir. İlk öğeyi vermeden önce kaynağını oluşturan bir sorgu işleci kullanırsanız, uygulamanız için küçük bir bellek ayak izi tutmayabileceğinizi unutmayın.

içinde açıklanan tekniği kullansanız bile, dönüştürülen belgeyi içeren bir XML ağacını derlemeye çalışırsanız, bellek kullanımı çok büyük olabilir.

Aşağıdaki örnek, üst bilgi bilgilerine erişimle XML parçalarını akışla aktarma başlığındaki örneği oluşturur.

Bu örnekte, çıkışın akışını yapmak için ertelenen XStreamingElement yürütme özellikleri kullanılır.

Özel eksenin (StreamCustomerItem) özel olarak yazıldığını, böylece , Customerve öğeleri olan Namebir belge beklediğini ve Item bu öğelerin aşağıdaki Source.xml belgede olduğu gibi düzenlendiğini unutmayın. Ancak daha sağlam bir uygulama, kaynak belgeyi XSD ile doğrular veya geçersiz bir belgeyi ayrıştırmaya hazır olur.

Kaynak belge Source.xmlaşağıdadır:

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

Aşağıdaki kod, kaynak XML akışını yapmak için kullanan bir XmlReader yöntem içerir. Yeni XML akışını yapmak için kullanır XStreamingElement .

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

Bu örnek aşağıdaki çıkışı oluşturur:

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

Açıklamalar

Bu sınıf, ertelenmiş akış çıkışını destekleyen bir XML ağacı oluşturmanıza olanak tanır. Kullanarak XML ağacı oluşturmaya çok benzer bir şekilde bir XML ağacı XElementoluşturmak için bu sınıfı kullanırsınız. Ancak, temel bir fark vardır. kullanarak XElementBIR XML ağacı oluştururken içerik belirtmek için LINQ sorgusu kullandığınızda, sorgu değişkeni XML ağacının oluşturulması sırasında yinelenir ve sorgunun sonuçları XML ağacına eklenir. Buna karşılık, kullanarak XStreamingElementbir XML ağacı oluşturduğunuzda, sorgu değişkenine yönelik bir başvuru yinelenmeden XML ağacında depolanır. Sorgular yalnızca seri hale getirildiğinde yinelenir. Bu, daha küçük bir bellek ayak izini korurken daha büyük XML ağaçları oluşturmanıza olanak tanır.

Metin dosyası gibi bir giriş kaynağından akış oluşturuyorsanız, çok büyük bir metin dosyasını okuyabilir ve küçük bir bellek ayak izi tutarken çok büyük bir XML belgesi oluşturabilirsiniz.

Başka bir senaryo, belleğe yüklenmiş büyük bir XML ağacınız olması ve belgenin dönüştürülmüş bir sürümünü oluşturmak istemenizdir. kullanarak XElementyeni bir belge oluşturursanız, dönüştürme tamamlandıktan sonra bellekte iki büyük XML ağacınız olur. Ancak, kullanarak XStreamingElementyeni XML ağacı oluşturursanız çalışma kümeniz etkili bir şekilde ikiye bölünecektir.

kullanan XStreamingElementbir programda hata ayıklarken bir nesnenin değerinin görüntülenmesinin yönteminin çağrılmaya neden ToString olduğunu unutmayın. Bu, XML'nin serileştirilmesine neden olur. Akış öğesi sorgunuzun semantiği, akış öğesinin yalnızca bir kez akışla aktarılabileceği şekildeyse, bu hata ayıklama deneyiminizde istenmeyen davranışlara neden olabilir.

Oluşturucular

Name	Description
XStreamingElement(XName, Object)	Belirtilen ad ve içerikle sınıfının yeni bir örneğini XStreamingElement başlatır.
XStreamingElement(XName, Object[])	Belirtilen ad ve içerikle sınıfının yeni bir örneğini XStreamingElement başlatır.
XStreamingElement(XName)	Belirtilen XElementöğesinden sınıfının yeni bir örneğini XName başlatır.

Özellikler

Name	Description
Name	Bu akış öğesinin adını alır veya ayarlar.

Yöntemler

Name	Description
Add(Object)	Belirtilen içeriği bu XStreamingElementöğesine alt öğe olarak ekler.
Add(Object[])	Belirtilen içeriği bu XStreamingElementöğesine alt öğe olarak ekler.
Equals(Object)	Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object)
GetHashCode()	Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object)
GetType()	Geçerli örneğin Type alır. (Devralındığı yer: Object)
MemberwiseClone()	Geçerli Objectbasit bir kopyasını oluşturur. (Devralındığı yer: Object)
Save(Stream, SaveOptions)	Bunu XStreamingElement , isteğe bağlı olarak biçimlendirme davranışını belirterek belirtilen Streamöğesine aktarır.
Save(Stream)	Bunu XStreamingElement belirtilen Streamöğesine döndürür.
Save(String, SaveOptions)	Bu akış öğesini bir dosyaya seri hale getirerek isteğe bağlı olarak biçimlendirmeyi devre dışı bırak.
Save(String)	Bu akış öğesini bir dosyaya seri hale getirme.
Save(TextWriter, SaveOptions)	Bu akış öğesini bir TextWriterolarak seri hale getirerek isteğe bağlı olarak biçimlendirmeyi devre dışı bırak.
Save(TextWriter)	Bu akış öğesini bir TextWriterolarak serileştirin.
Save(XmlWriter)	Bu akış öğesini bir XmlWriterolarak serileştirin.
ToString()	Bu akış öğesi için biçimlendirilmiş (girintili) XML'yi döndürür.
ToString(SaveOptions)	İsteğe bağlı olarak biçimlendirmeyi devre dışı bırakarak bu akış öğesinin XML'sini döndürür.
WriteTo(XmlWriter)	Bu akış öğesini bir XmlWriteröğesine yazar.

Şunlara uygulanır

Ayrıca bkz.

LINQ to XML'e genel bakış

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?