StoryFragment Klasse

Definition

Stellt den gesamten oder einen Teil eines Textabschnitts in einem XPS-Dokument dar.

public ref class StoryFragment
public ref class StoryFragment : System::Collections::Generic::IEnumerable<System::Windows::Documents::DocumentStructures::BlockElement ^>, System::Windows::Markup::IAddChild
public class StoryFragment
[System.Windows.Markup.ContentProperty("BlockElementList")]
public class StoryFragment : System.Collections.Generic.IEnumerable<System.Windows.Documents.DocumentStructures.BlockElement>, System.Windows.Markup.IAddChild
type StoryFragment = class
    interface IAddChild
[<System.Windows.Markup.ContentProperty("BlockElementList")>]
type StoryFragment = class
    interface IAddChild
    interface seq<BlockElement>
    interface IEnumerable
[<System.Windows.Markup.ContentProperty("BlockElementList")>]
type StoryFragment = class
    interface seq<BlockElement>
    interface IEnumerable
    interface IAddChild
Public Class StoryFragment
Public Class StoryFragment
Implements IAddChild, IEnumerable(Of BlockElement)
Vererbung
StoryFragment
Attribute
Implementiert

Beispiele

Das folgende Beispiel zeigt den <StoryFragment> Teil eines XPS-Dokuments (XML Paper Specification).

<StoryFragment StoryName="DocumentBody" FragmentType="Content">
  <SectionStructure>
    <ParagraphStructure>
      <NamedElement NameReference="Pg1Heading1" />
    </ParagraphStructure>

    <ParagraphStructure>
      <NamedElement NameReference="Pg1P1" />
    </ParagraphStructure>

    <ParagraphStructure>
      <NamedElement NameReference="Pg1P2" />
    </ParagraphStructure>

    <ParagraphStructure>
      <NamedElement NameReference="Pg1P3" />
    </ParagraphStructure>

    <ParagraphStructure>
      <NamedElement NameReference="Pg1P4" />
    </ParagraphStructure>

    <ParagraphStructure>
      <NamedElement NameReference="Pg1P5" />
    </ParagraphStructure>

    <ParagraphStructure>
      <NamedElement NameReference="Pg1Heading2" />
    </ParagraphStructure>

    <ParagraphStructure>
      <NamedElement NameReference="Pg1P6" />
    </ParagraphStructure>

    <ParagraphStructure>
      <NamedElement NameReference="Pg1P7" />
    </ParagraphStructure>

    <TableStructure>
      <TableRowGroupStructure>

        <TableRowStructure>
          <TableCellStructure>
            <ParagraphStructure>
              <NamedElement NameReference="R1C1P1" />
            </ParagraphStructure>
          </TableCellStructure>
          <TableCellStructure>
            <ParagraphStructure>
              <NamedElement NameReference="R1C2P1" />
            </ParagraphStructure>
          </TableCellStructure>
        </TableRowStructure>

        <TableRowStructure>
          <TableCellStructure>
            <ParagraphStructure>
              <NamedElement NameReference="R2C1P1" />
            </ParagraphStructure>
          </TableCellStructure>
          <TableCellStructure>
            <ParagraphStructure>
              <NamedElement NameReference="R2C2P1" />
            </ParagraphStructure>
            <ParagraphStructure>
              <NamedElement NameReference="R2C2P2" />
            </ParagraphStructure>
          </TableCellStructure>
        </TableRowStructure>

        <TableRowStructure>
          <TableCellStructure>
            <ParagraphStructure>
              <NamedElement NameReference="R3C1P1" />
            </ParagraphStructure>
          </TableCellStructure>
          <TableCellStructure>
            <ParagraphStructure>
              <NamedElement NameReference="R3C2P1" />
            </ParagraphStructure>
          </TableCellStructure>
        </TableRowStructure>

        <TableRowStructure>
          <TableCellStructure>
            <ParagraphStructure>
              <NamedElement NameReference="R4C1P1" />
            </ParagraphStructure>
          </TableCellStructure>
          <TableCellStructure>
            <ParagraphStructure>
              <NamedElement NameReference="R4C2P1" />
            </ParagraphStructure>
          </TableCellStructure>
        </TableRowStructure>

        <TableRowStructure>
          <TableCellStructure>
            <ParagraphStructure>
              <NamedElement NameReference="R5C1P1" />
            </ParagraphStructure>
          </TableCellStructure>
          <TableCellStructure>
            <ParagraphStructure>
              <NamedElement NameReference="R5C2P1" />
            </ParagraphStructure>
          </TableCellStructure>
        </TableRowStructure>

      </TableRowGroupStructure>
    </TableStructure>
  </SectionStructure>
</StoryFragment>

Hinweise

Eine XPS-Geschichte in einem XPS-Dokument entspricht ungefähr einer Geschichte in einer Zeitung oder einem Magazin. Dabei handelt es sich um text- und grafische Inhalte, die normalerweise zu einem einzelnen Thema in einem einzelnen XPS-Dokument enthalten sind. In der Regel erstreckt es sich über mehrere Seiten, kann aber kürzer sein als eine Seite wie eine Randleiste - boxed story - in einem Magazin. Eine Geschichte kann auch diskontinuierlich sein wie eine Frontpage-Zeitungsgeschichte, die auf Seite 4 fortgesetzt wird. Folglich kann eine bestimmte Seite mehr als eine Geschichte und Teile von mehr als einer Geschichte enthalten. Eine Kopf- oder Fußzeile ist auch eine besondere Art von Geschichte, die vollständig auf einer einzelnen Seite enthalten ist.

Ein StoryFragment stellt die gesamte Oder einen Teil einer Geschichte dar. Es kann sich nie über mehr als eine Seite erstrecken, aber es kann die gesamte Seite belegen oder eine Seite mit anderen Fragmenten freigeben. Wenn sich eine Geschichte auf mehr als einer Seite befindet, ist jeder Teil davon auf jeder Seite ein separates Fragment. Obwohl Geschichten diskontinuierliche Fragmente aufweisen können, kann kein Fragment selbst diskontinuierlich sein.

Nur ein StoryFragments Element kann ein übergeordnetes element von sein StoryFragment. Die Position der StoryBreak Elemente in einem StoryFragment gibt an, ob die Geschichte in mehreren Fragmenten enthalten ist und ob die zusätzlichen Fragmente dem aktuellen Fragment vorangehen oder folgen.

Wenn ein StoryFragment in der Mitte eines strukturellen Elements endet, z. B. ein <TableRowGroupStructure>, müssen XPS-dokumentproduzierende Anwendungen ein geeignetes Endtag für das Element (in diesem Fall </TableRowGroupStructure>) vor dem </StoryFragment> Tag einfügen, obwohl die Struktur in einem späteren Fragment fortgesetzt wird. (Dies ist erforderlich, um sicherzustellen, dass die Elementstruktur innerhalb des StoryFragment gültigen XML-Elements ist.) Das Fragment, das die Geschichte fortsetzt, muss mit einem öffnenden Tag für die unterbrochene Struktur beginnen. Die gesamte Struktur unterbrochener Strukturen muss auf die gleiche Weise behandelt werden (mit einer Ausnahme, die unten erläutert wird): Endtags müssen für jedes nicht übereinstimmende Starttag über dem Unterbrechungspunkt hinzugefügt werden.

Die Ausnahme gilt, wenn die Textabschnittsunterbrechung unmittelbar nach einem </TableCellStructure> Tag auftritt. Dann muss die produzierende Anwendung eine leere Tabellenzellenstruktur (<TableCellStructure></TableCellStructure>) an der entsprechenden Stelle im Fragment einfügen, die die Geschichte fortsetzt. Dies ist erforderlich, damit die Verwendung von Anwendungen, die alle Fragmente einer bestimmten Geschichte zusammenführen müssen, dazu einen einfachen Algorithmus verwenden kann.

Angenommen, eine Anwendung wollte einem XPS-Dokument das folgende Material hinzufügen:

<SectionStructure>  
   <TableStructure>  
      <TableRowGroupStructure>  
         <TableRowStructure>  
            <TableCellStructure>  
               <ParagraphStructure>  
                  <NamedElement NameReference="SomeContent" />  
               </ParagraphStructure>  
            </TableCellStructure>  
            <TableCellStructure>  
               <ParagraphStructure>  
                  <NamedElement NameReference="MoreContent" />  
               </ParagraphStructure>  
            </TableCellStructure>  
         </TableRowStructure>  
         <TableRowStructure>  
            <TableCellStructure>  
               <ParagraphStructure>  
                  <NamedElement NameReference="EvenMoreContent" />  
               </ParagraphStructure>  
            </TableCellStructure>  
            <TableCellStructure>  
               <ParagraphStructure>  
                  <NamedElement NameReference="LastContent" />  
               </ParagraphStructure>  
            </TableCellStructure>  
         </TableRowStructure>  
      </TableRowGroupStructure>  
   </TableStructure>  
</SectionStructure>  

Wenn ein Seitenwechsel ein Ende des Fragments unmittelbar hinter " </TableCellStructure> SomeContent" erzwingt, muss die Anwendung die Aufteilung erstellen, wie im folgenden Beispiel gezeigt:

<StoryFragment StoryName="MyStory" FragmentType="Content">  
 <SectionStructure>  
    <TableStructure>  
       <TableRowGroupStructure>  
          <TableRowStructure>  
             <TableCellStructure>  
                <ParagraphStructure>  
                   <NamedElement NameReference="SomeContent" />  
                </ParagraphStructure>   
             </TableCellStructure>  
<!-- lines from here to end of fragment added by producer-->  
          </TableRowStructure>  
       </TableRowGroupStructure>  
    </TableStructure>  
 </SectionStructure>  
</StoryFragment>  

<StoryFragment StoryName="MyStory" FragmentType="Content">  
 <SectionStructure>  
    <TableStructure>  
       <TableRowGroupStructure>  
          <TableRowStructure>  
             <TableCellStructure>   
              <!-- extra cell added by producer-->  
             </TableCellStructure>  
<!-- lines from here to start of fragment added by producer-->  
             <TableCellStructure>  
                <ParagraphStructure>  
                   <NamedElement NameReference="MoreContent" />  
                </ParagraphStructure>  
             </TableCellStructure>  
          </TableRowStructure>  
          <TableRowStructure>  
             <TableCellStructure>  
                <ParagraphStructure>  
                   <NamedElement NameReference="EvenMoreContent" />  
                </ParagraphStructure>  
             </TableCellStructure>  
             <TableCellStructure>  
                <ParagraphStructure>  
                   <NamedElement NameReference="LastContent" />  
                </ParagraphStructure>  
             </TableCellStructure>  
          </TableRowStructure>  
       </TableRowGroupStructure>  
    </TableStructure>  
 </SectionStructure>  
</StoryFragment>  

Eine Anwendung, die das Dokument liest, muss diesen Inhalt möglicherweise zusammenführen. Betrachten Sie beispielsweise einen XPS-Viewer mit der Schaltfläche Ganze Geschichte in Zwischenablage kopieren . oder eine XPS for the Blind-Anwendung , die Geschichten an einen Sprachsynthesizer übergeben hat. Einige Anwendungen, die das Dokument lesen, müssen möglicherweise eine Teilmenge der Fragmente eines Storys zusammenführen. Beispielsweise muss ein Feature, das einen ganzen Absatz durch Dreifachklick in die Zwischenablage kopiert, immer dann eine Zusammenführung durchführen, wenn der Absatz einen Seitenumbruch überspannt, da ein solcher Absatz zwischen zwei StoryFragments aufgeteilt würde.

Verwenden Sie zum Zusammenführen diesen Algorithmus:

  1. Löschen Sie das </StoryFragment> vom Ende des ersten fragments, das zusammengeführt werden soll, und löschen Sie das <StoryFragment> vom Anfang des zweiten Fragments.

  2. Wenn das letzte schließende Tag des ersten Fragments vom gleichen Typ ist wie das erste öffnende Tag des zweiten Fragments (und es sind keine <NamedElement> Tags), löschen Sie beide.

  3. Wiederholen Sie Schritt 2, bis sich die beiden Fragmente in einem der folgenden Zustände befinden:

    • Zwischen dem letzten Endtag des führenden Fragments und dem ersten Starttag des nachfolgenden Fragments gibt es keine Typmatches mehr.

    • Das letzte Endtag des führenden Fragments und das erste Starttag des nachfolgenden Fragments sind beide <NamedElement> Tags.

Wenn im obigen Beispiel die leere Zelle nicht von der produzierenden Anwendung hinzugefügt wurde, würde eine Zusammenführung der Fragmente eine Tabelle erzeugen, deren erste Zeile nur eine Zelle mit den Verweisen "SomeContent" und "MoreContent" anstelle der ursprünglichen ersten Zeile mit zwei Zellen mit jeweils einem einzelnen Verweis enthält.

Wenn die gesamte Geschichte zusammengeführt wird, sollte der Algorithmus für jedes nachfolgende Fragment wiederholt werden, das Teil derselben Geschichte ist. Die Fragmente, die zu einer Geschichte gehören, werden im <Story> -Element indiziert. Siehe Abschnitt 9.1.15 der XPS-Spezifikation (XML Paper Specification), die Sie unter XPS: Spezifikations- und Lizenzdownloads erhalten können. Das letzte Fragment für eine bestimmte Geschichte enthält ein StoryBreak Element als letztes untergeordnetes Element.

Konstruktoren

StoryFragment()

Initialisiert eine neue Instanz der StoryFragment-Klasse.

Eigenschaften

FragmentName

Ruft den Namen des Textabschnittsfragments ab oder legt diesen fest.

FragmentType

Ruft den Typ des Fragments ab oder legt diesen fest.

StoryName

Ruft den Namen des Textabschnitts ab oder legt diesen fest.

Methoden

Add(BlockElement)

Fügt dem Textabschnittsfragment einen Block hinzu.

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)

Explizite Schnittstellenimplementierungen

IAddChild.AddChild(Object)

Dieser Member unterstützt die .NET Framework-Infrastruktur und ist nicht für die direkte Verwendung in Code vorgesehen.

IAddChild.AddText(String)

Fügt dem Objekt den Textinhalt eines Knotens hinzu.

IEnumerable.GetEnumerator()

Diese Methode wurde nicht implementiert.

IEnumerable<BlockElement>.GetEnumerator()

Diese Methode wurde nicht implementiert.

Erweiterungsmethoden

CopyToDataTable<T>(IEnumerable<T>)

Gibt eine DataTable zurück, die Kopien der DataRow-Objekte enthält, wenn ein IEnumerable<T>-Eingabeobjekt vorhanden ist, bei dem der generische Parameter T den Wert DataRow hat.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

Kopiert DataRow-Objekte in die angegebene DataTable, bei einem IEnumerable<T>-Eingabeobjekt, bei dem der generische Parameter T den Wert DataRow aufweist.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

Kopiert DataRow-Objekte in die angegebene DataTable, bei einem IEnumerable<T>-Eingabeobjekt, bei dem der generische Parameter T den Wert DataRow aufweist.

Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)

Wendet eine Akkumulatorfunktion auf eine Sequenz an

Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)

Wendet eine Akkumulatorfunktion auf eine Sequenz an Der angegebene Startwert wird als erster Akkumulatorwert verwendet.

Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)

Wendet eine Akkumulatorfunktion auf eine Sequenz an Der angegebene Startwert wird als erster Akkumulatorwert verwendet, und der Ergebniswert wird mit der angegebenen Funktion ausgewählt.

All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Bestimmt, ob alle Elemente einer Sequenz eine Bedingung erfüllen.

Any<TSource>(IEnumerable<TSource>)

Bestimmt, ob eine Sequenz Elemente enthält.

Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Bestimmt, ob ein Element einer Sequenz eine Bedingung erfüllt.

Append<TSource>(IEnumerable<TSource>, TSource)

Fügt einen Wert an das Ende der Sequenz an.

AsEnumerable<TSource>(IEnumerable<TSource>)

Gibt die Eingabe als IEnumerable<T> typisiert zurück

Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Berechnet den Durchschnitt einer Sequenz von Decimal-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Berechnet den Durchschnitt einer Sequenz von Double-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Berechnet den Durchschnitt einer Sequenz von Int32-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Berechnet den Durchschnitt einer Sequenz von Int64-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Berechnet den Durchschnitt einer Sequenz von Decimal-Werten, die NULL zulassen, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Berechnet den Durchschnitt einer Sequenz von Double-Werten, die NULL zulassen, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Berechnet den Durchschnitt einer Sequenz von Int32-Werten, die NULL zulassen, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Berechnet den Durchschnitt einer Sequenz von Int64-Werten, die NULL zulassen, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Berechnet den Durchschnitt einer Sequenz von Single-Werten, die NULL zulassen, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Berechnet den Durchschnitt einer Sequenz von Single-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

Cast<TResult>(IEnumerable)

Wandelt die Elemente eines IEnumerable in den angegebenen Typ um

Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Verkettet zwei Sequenzen

Contains<TSource>(IEnumerable<TSource>, TSource)

Bestimmt mithilfe des Standardgleichheitsvergleichs, ob eine Sequenz ein angegebenes Element enthält

Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)

Bestimmt mithilfe eines angegebenen IEqualityComparer<T>, ob eine Sequenz ein angegebenes Element enthält

Count<TSource>(IEnumerable<TSource>)

Gibt die Anzahl der Elemente in einer Sequenz zurück

Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Gibt eine Zahl zurück, die die Anzahl der Elemente in der angegebenen Sequenz angibt, die eine Bedingung erfüllen

DefaultIfEmpty<TSource>(IEnumerable<TSource>)

Gibt die Elemente der angegebenen Sequenz oder den Standardwert des Typparameters in einer Singletonauflistung zurück, wenn die Sequenz leer ist

DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)

Gibt die Elemente der angegebenen Sequenz oder den angegebenen Wert in einer Singletonauflistung zurück, wenn die Sequenz leer ist.

Distinct<TSource>(IEnumerable<TSource>)

Gibt mithilfe des Standardgleichheitsvergleichs zum Vergleichen von Werten unterschiedliche Elemente aus einer Sequenz zurück

Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Gibt mithilfe eines angegebenen IEqualityComparer<T> zum Vergleichen von Werten unterschiedliche Elemente aus einer Sequenz zurück

ElementAt<TSource>(IEnumerable<TSource>, Int32)

Gibt das Element an einem angegebenen Index in einer Sequenz zurück

ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)

Gibt das Element an einem angegebenen Index in einer Sequenz oder einen Standardwert zurück, wenn der Index außerhalb des gültigen Bereichs liegt.

Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Erzeugt die Differenzmenge zweier Sequenzen mithilfe des Standardgleichheitsvergleichs zum Vergleichen von Werten

Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Erzeugt mithilfe des angegebenen IEqualityComparer<T> die Differenzmenge zweier Sequenzen zum Vergleichen von Werten

First<TSource>(IEnumerable<TSource>)

Gibt das erste Element einer Sequenz zurück

First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Gibt das erste Element in einer Sequenz zurück, das eine angegebene Bedingung erfüllt.

FirstOrDefault<TSource>(IEnumerable<TSource>)

Gibt das erste Element einer Sequenz oder einen Standardwert zurück, wenn die Sequenz keine Elemente enthält.

FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Gibt das erste Element der Sequenz zurück, das eine Bedingung erfüllt, oder einen Standardwert, wenn ein solches Element nicht gefunden wird.

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und vergleicht die Schlüssel mithilfe eines angegebenen Vergleichs

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und projiziert die Elemente für jede Gruppe mithilfe einer angegebenen Funktion

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Gruppiert die Elemente einer Sequenz entsprechend einer Schlüsselauswahlfunktion Die Schlüssel werden mithilfe eines Vergleichs verglichen, und die Elemente jeder Gruppe werden mithilfe einer angegebenen Funktion projiziert.

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)

Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und erstellt aus jeder Gruppe und ihrem Schlüssel einen Ergebniswert.

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)

Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und erstellt aus jeder Gruppe und ihrem Schlüssel einen Ergebniswert. Die Schlüssel werden mithilfe eines angegebenen Vergleichs verglichen.

GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)

Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und erstellt aus jeder Gruppe und ihrem Schlüssel einen Ergebniswert. Die Elemente jeder Gruppe werden mithilfe einer angegebenen Funktion projiziert.

GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)

Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und erstellt aus jeder Gruppe und ihrem Schlüssel einen Ergebniswert. Schlüsselwerte werden mithilfe eines angegebenen Vergleichs verglichen, und die Elemente jeder Gruppe werden mithilfe einer angegebenen Funktion projiziert.

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>)

Korreliert die Elemente von zwei Sequenzen anhand der Gleichheit der Schlüssel und gruppiert die Ergebnisse Schlüssel werden mithilfe des Standardgleichheitsvergleichs verglichen.

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)

Korreliert die Elemente von zwei Sequenzen anhand der Gleichheit der Schlüssel und gruppiert die Ergebnisse Schlüssel werden mithilfe eines angegebenen IEqualityComparer<T> verglichen.

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Erzeugt die Schnittmenge zweier Sequenzen mithilfe des Standardgleichheitsvergleichs zum Vergleichen von Werten

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Erzeugt mithilfe des angegebenen IEqualityComparer<T> zum Vergleichen von Werten die Schnittmenge von zwei Sequenzen

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)

Korreliert die Elemente von zwei Sequenzen auf der Grundlage von übereinstimmenden Schlüsseln Schlüssel werden mithilfe des Standardgleichheitsvergleichs verglichen.

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)

Korreliert die Elemente von zwei Sequenzen auf der Grundlage von übereinstimmenden Schlüsseln Schlüssel werden mithilfe eines angegebenen IEqualityComparer<T> verglichen.

Last<TSource>(IEnumerable<TSource>)

Gibt das letzte Element einer Sequenz zurück

Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Gibt das letzte Element einer Sequenz zurück, das eine angegebene Bedingung erfüllt.

LastOrDefault<TSource>(IEnumerable<TSource>)

Gibt das letzte Element einer Sequenz oder einen Standardwert zurück, wenn die Sequenz keine Elemente enthält.

LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Gibt das letzte Element einer Sequenz, das eine Bedingung erfüllt, oder einen Standardwert zurück, wenn ein solches Element nicht gefunden wird.

LongCount<TSource>(IEnumerable<TSource>)

Gibt ein Int64 zurück, das die Gesamtanzahl der Elemente in einer Sequenz darstellt

LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Gibt ein Int64 zurück, das die Anzahl der Elemente in einer Sequenz darstellt, die eine Bedingung erfüllen

Max<TSource>(IEnumerable<TSource>)

Gibt den Höchstwert in einer generischen Sequenz zurück

Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Decimal-Wert zurück

Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Double-Wert zurück

Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Int32-Wert zurück

Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Int64-Wert zurück

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Decimal-Wert zurück, der NULL-Werte zulässt

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Double-Wert zurück, der NULL-Werte zulässt

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Int32-Wert zurück, der NULL-Werte zulässt

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Int64-Wert zurück, der NULL-Werte zulässt

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Single-Wert zurück, der NULL-Werte zulässt

Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Single-Wert zurück

Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

Ruft für jedes Element einer generischen Sequenz eine Transformationsfunktion auf, und gibt den höchsten Ergebniswert zurück

Min<TSource>(IEnumerable<TSource>)

Gibt den Mindestwert in einer generischen Sequenz zurück

Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Decimal-Wert zurück

Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Double-Wert zurück

Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Int32-Wert zurück

Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Int64-Wert zurück

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Decimal-Wert zurück, der NULL-Werte zulässt

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Double-Wert zurück, der NULL-Werte zulässt

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Int32-Wert zurück, der NULL-Werte zulässt

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Int64-Wert zurück, der NULL-Werte zulässt

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Single-Wert zurück, der NULL-Werte zulässt

Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Single-Wert zurück

Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

Ruft für jedes Element einer generischen Sequenz eine Transformationsfunktion auf, und gibt den niedrigsten Ergebniswert zurück

OfType<TResult>(IEnumerable)

Filtert die Elemente eines IEnumerable anhand eines angegebenen Typs

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Sortiert die Elemente einer Sequenz in aufsteigender Reihenfolge nach einem Schlüssel

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Sortiert die Elemente einer Sequenz mithilfe eines angegebenen Vergleichs in aufsteigender Reihenfolge

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Sortiert die Elemente einer Sequenz in absteigender Reihenfolge nach einem Schlüssel

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Sortiert die Elemente einer Sequenz mithilfe eines angegebenen Vergleichs in absteigender Reihenfolge.

Prepend<TSource>(IEnumerable<TSource>, TSource)

Fügt einen Wert am Anfang der Sequenz ein.

Reverse<TSource>(IEnumerable<TSource>)

Kehrt die Reihenfolge der Elemente in einer Sequenz um

Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

Projiziert jedes Element einer Sequenz in ein neues Format.

Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)

Projiziert jedes Element einer Sequenz in ein neues Format, indem der Index des Elements integriert wird

SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)

Projiziert jedes Element einer Sequenz in ein IEnumerable<T>, und fasst die resultierenden Sequenzen in einer einzigen Sequenz zusammen

SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)

Projiziert jedes Element einer Sequenz in ein IEnumerable<T>, und fasst die resultierenden Sequenzen zu einer einzigen Sequenz zusammen Der Index jedes Quellelements wird im projizierten Format des jeweiligen Elements verwendet.

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

Projiziert jedes Element einer Sequenz in ein IEnumerable<T>, fasst die resultierenden Sequenzen zu einer einzigen Sequenz zusammen und ruft für jedes Element in dieser Sequenz eine Ergebnisauswahlfunktion auf.

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

Projiziert jedes Element einer Sequenz in ein IEnumerable<T>, fasst die resultierenden Sequenzen zu einer einzigen Sequenz zusammen und ruft für jedes Element in dieser Sequenz eine Ergebnisauswahlfunktion auf. Der Index jedes Quellelements wird im projizierten Zwischenformat des jeweiligen Elements verwendet.

SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Bestimmt, ob zwei Sequenzen gleich sind, indem die Elemente mithilfe des Standardgleichheitsvergleichs für ihren Typ verglichen werden

SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Bestimmt, ob zwei Sequenzen gleich sind, indem ihre Elemente mithilfe eines angegebenen IEqualityComparer<T> verglichen werden

Single<TSource>(IEnumerable<TSource>)

Gibt das einzige Element einer Sequenz zurück und löst eine Ausnahme aus, wenn nicht genau ein Element in der Sequenz vorhanden ist.

Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Gibt das einzige Element einer Sequenz zurück, das eine angegebene Bedingung erfüllt, und löst eine Ausnahme aus, wenn mehrere solche Elemente vorhanden sind.

SingleOrDefault<TSource>(IEnumerable<TSource>)

Gibt das einzige Element einer Sequenz oder einen Standardwert zurück, wenn die Sequenz leer ist. Diese Methode löst eine Ausnahme aus, wenn mehrere Elemente in der Sequenz vorhanden sind.

SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Gibt das einzige Element einer Sequenz, das eine angegebene Bedingung erfüllt, oder einen Standardwert zurück, wenn kein solches Element vorhanden ist. Diese Methode löst eine Ausnahme aus, wenn mehrere Elemente die Bedingung erfüllen.

Skip<TSource>(IEnumerable<TSource>, Int32)

Umgeht eine festgelegte Anzahl von Elementen in einer Sequenz und gibt dann die übrigen Elemente zurück

SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Umgeht Elemente in einer Sequenz, solange eine angegebene Bedingung true ist, und gibt dann die übrigen Elemente zurück

SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Umgeht Elemente in einer Sequenz, solange eine angegebene Bedingung true ist, und gibt dann die übrigen Elemente zurück In der Logik der Prädikatfunktion wird der Index des Elements verwendet.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Berechnet die Summe einer Sequenz von Decimal-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Berechnet die Summe einer Sequenz von Double-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Berechnet die Summe einer Sequenz von Int32-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Berechnet die Summe einer Sequenz von Int64-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Berechnet die Summe einer Sequenz von Decimal-Werten, die NULL zulassen, und die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Berechnet die Summe einer Sequenz von Double-Werten, die NULL zulassen, und die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Berechnet die Summe einer Sequenz von Int32-Werten, die NULL zulassen, und die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Berechnet die Summe einer Sequenz von Int64-Werten, die NULL zulassen, und die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Berechnet die Summe einer Sequenz von Single-Werten, die NULL zulassen, und die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Berechnet die Summe einer Sequenz von Single-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

Take<TSource>(IEnumerable<TSource>, Int32)

Gibt eine angegebene Anzahl von zusammenhängenden Elementen ab dem Anfang einer Sequenz zurück

TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Gibt Elemente aus einer Sequenz zurück, solange eine angegebene Bedingung TRUE ist

TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Gibt Elemente aus einer Sequenz zurück, solange eine angegebene Bedingung TRUE ist In der Logik der Prädikatfunktion wird der Index des Elements verwendet.

ToArray<TSource>(IEnumerable<TSource>)

Erstellt ein Array aus einem IEnumerable<T>.

ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Erstellt ein Dictionary<TKey,TValue> aus einem IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion

ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Erstellt ein Dictionary<TKey,TValue> aus einem IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion und eines angegebenen Schlüsselvergleichs

ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Erstellt ein Dictionary<TKey,TValue> aus einem IEnumerable<T> entsprechend der angegebenen Schlüsselauswahlfunktion und Elementauswahlfunktion

ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Erstellt ein Dictionary<TKey,TValue> aus einem IEnumerable<T> entsprechend einer angegebenen Schlüsselauswahlfunktion, einem Vergleich und einer Elementauswahlfunktion

ToHashSet<TSource>(IEnumerable<TSource>)

Erstellt ein HashSet<T> aus einem IEnumerable<T>.

ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Erstellt ein HashSet<T>-Element aus einem IEnumerable<T>-Element mithilfe des comparer zum Vergleichen von Schlüsseln.

ToList<TSource>(IEnumerable<TSource>)

Erstellt ein List<T> aus einem IEnumerable<T>.

ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Erstellt ein Lookup<TKey,TElement> aus einem IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion

ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Erstellt ein Lookup<TKey,TElement> aus einem IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion und eines angegebenen Schlüsselvergleichs

ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Erstellt ein Lookup<TKey,TElement> aus einem IEnumerable<T> entsprechend der angegebenen Schlüsselauswahlfunktion und Elementauswahlfunktion

ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Erstellt ein Lookup<TKey,TElement> aus einem IEnumerable<T> entsprechend einer angegebenen Schlüsselauswahlfunktion, einem Vergleich und einer Elementauswahlfunktion

Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Erzeugt die Vereinigungsmenge von zwei Sequenzen mithilfe des Standardgleichheitsvergleichs

Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Erzeugt mithilfe eines angegebenen IEqualityComparer<T> die Vereinigungsmenge von zwei Sequenzen

Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Filtert eine Sequenz von Werten basierend auf einem Prädikat.

Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Filtert eine Sequenz von Werten basierend auf einem Prädikat. In der Logik der Prädikatfunktion wird der Index der einzelnen Elemente verwendet.

Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)

Wendet eine Funktion auf die entsprechenden Elemente von zwei Sequenzen an, und erzeugt eine Sequenz der Ergebnisse

AsParallel(IEnumerable)

Ermöglicht die Parallelisierung einer Abfrage.

AsParallel<TSource>(IEnumerable<TSource>)

Ermöglicht die Parallelisierung einer Abfrage.

AsQueryable(IEnumerable)

Konvertiert einen IEnumerable in einen IQueryable.

AsQueryable<TElement>(IEnumerable<TElement>)

Konvertiert ein generisches IEnumerable<T> in ein generisches IQueryable<T>.

Ancestors<T>(IEnumerable<T>)

Gibt eine Auflistung von Elementen zurück, die die übergeordneten Elemente der einzelnen Knoten in der Quellauflistung enthält.

Ancestors<T>(IEnumerable<T>, XName)

Gibt eine gefilterte Auflistung von Elementen zurück, die die übergeordneten Elemente der einzelnen Knoten in der Quellauflistung enthält. Nur Elemente, die über einen übereinstimmenden XName verfügen, sind in der Auflistung enthalten.

DescendantNodes<T>(IEnumerable<T>)

Gibt eine Auflistung der Nachfolgerknoten jedes Dokuments und Elements in der Quellauflistung zurück.

Descendants<T>(IEnumerable<T>)

Gibt eine Auflistung von Elementen zurück, die die Nachfolgerelemente jedes Elements und Dokuments in der Quellauflistung enthält.

Descendants<T>(IEnumerable<T>, XName)

Gibt eine gefilterte Auflistung von Elementen zurück, die die Nachfolgerelemente jedes Elements und Dokuments in der Quellauflistung enthält. Nur Elemente, die über einen übereinstimmenden XName verfügen, sind in der Auflistung enthalten.

Elements<T>(IEnumerable<T>)

Gibt eine Auflistung der untergeordneten Elemente jedes Elements und Dokuments in der Quellauflistung zurück.

Elements<T>(IEnumerable<T>, XName)

Gibt eine gefilterte Auflistung der untergeordneten Elemente jedes Elements und Dokuments in der Quellauflistung zurück. Nur Elemente, die über einen übereinstimmenden XName verfügen, sind in der Auflistung enthalten.

InDocumentOrder<T>(IEnumerable<T>)

Gibt eine in Dokumentreihenfolge sortierte Auflistung von Knoten zurück, die alle Knoten in der Quellauflistung enthält.

Nodes<T>(IEnumerable<T>)

Gibt eine Auflistung der untergeordneten Knoten jedes Dokuments und Elements in der Quellauflistung zurück.

Remove<T>(IEnumerable<T>)

Entfernt jeden Knoten in der Quellauflistung aus seinem übergeordneten Knoten.

Gilt für:

Weitere Informationen