ArraySegment<T> Struktur

Definition

Begrenzt einen Abschnitt eines eindimensionalen Arrays.Delimits a section of a one-dimensional array.

generic <typename T>
public value class ArraySegment : System::Collections::Generic::ICollection<T>, System::Collections::Generic::IEnumerable<T>, System::Collections::Generic::IList<T>, System::Collections::Generic::IReadOnlyCollection<T>, System::Collections::Generic::IReadOnlyList<T>
[System.Serializable]
public struct ArraySegment<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IList<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.Generic.IReadOnlyList<T>
type ArraySegment<'T> = struct
    interface IList<'T>
    interface IReadOnlyList<'T>
    interface ICollection<'T>
    interface seq<'T>
    interface IEnumerable
    interface IReadOnlyCollection<'T>
Public Structure ArraySegment(Of T)
Implements ICollection(Of T), IEnumerable(Of T), IList(Of T), IReadOnlyCollection(Of T), IReadOnlyList(Of T)

Typparameter

T

Der Typ der Elemente im Arraysegment.The type of the elements in the array segment.

Vererbung
ArraySegment<T>
Attribute
Implementiert

Beispiele

Im folgenden Codebeispiel wird eine ArraySegment<T>-Struktur an eine-Methode weitergeleitet.The following code example passes an ArraySegment<T> structure to a method.

using namespace System;


namespace Sample
{
    public ref class SampleArray  
    {
    public:
        static void Work()  
        {

            // Create and initialize a new string array.
            array <String^>^ words = {"The", "quick", "brown",
                "fox", "jumps", "over", "the", "lazy", "dog"};

            // Display the initial contents of the array.
            Console::WriteLine("The first array segment"
                " (with all the array's elements) contains:");
            PrintIndexAndValues(words);

            // Define an array segment that contains the entire array.
            ArraySegment<String^> segment(words);
            
            // Display the contents of the ArraySegment.
            Console::WriteLine("The first array segment"
                " (with all the array's elements) contains:");
            PrintIndexAndValues(segment);

            // Define an array segment that contains the middle five 
            // values of the array.
            ArraySegment<String^> middle(words, 2, 5);
            
            // Display the contents of the ArraySegment.
            Console::WriteLine("The second array segment"
                " (with the middle five elements) contains:");
            PrintIndexAndValues(middle);

            // Modify the fourth element of the first array 
            // segment
            segment.Array[3] = "LION";

            // Display the contents of the second array segment 
            // middle. Note that the value of its second element 
            // also changed.
            Console::WriteLine("After the first array segment"
                " is modified,the second array segment"
                " now contains:");
            PrintIndexAndValues(middle);
            Console::ReadLine();
        }

        static void PrintIndexAndValues(ArraySegment<String^>^ segment)  
        {
            for (int i = segment->Offset; 
                i < (segment->Offset + segment->Count); i++)  
            {
                Console::WriteLine("   [{0}] : {1}", i,
                    segment->Array[i]);
            }
            Console::WriteLine();
        }

        static void PrintIndexAndValues(array<String^>^ words) 
        {
            for (int i = 0; i < words->Length; i++)  
            {
                Console::WriteLine("   [{0}] : {1}", i,
                    words[i]);
            }
            Console::WriteLine();
        }
    };
}

int main()
{
    Sample::SampleArray::Work();
    return 0; 
}


    /* 
    This code produces the following output.

    The original array initially contains:
    [0] : The
    [1] : quick
    [2] : brown
    [3] : fox
    [4] : jumps
    [5] : over
    [6] : the
    [7] : lazy
    [8] : dog

    The first array segment (with all the array's elements) contains:
    [0] : The
    [1] : quick
    [2] : brown
    [3] : fox
    [4] : jumps
    [5] : over
    [6] : the
    [7] : lazy
    [8] : dog

    The second array segment (with the middle five elements) contains:
    [2] : brown
    [3] : fox
    [4] : jumps
    [5] : over
    [6] : the

    After the first array segment is modified, the second array segment now contains:
    [2] : brown
    [3] : LION
    [4] : jumps
    [5] : over
    [6] : the

    */

using System;

public class SamplesArray  {
 
   public static void Main()  {
 
      // Create and initialize a new string array.
      String[] myArr = { "The", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog" };
 
      // Display the initial contents of the array.
      Console.WriteLine( "The original array initially contains:" );
      PrintIndexAndValues( myArr );

      // Define an array segment that contains the entire array.
      ArraySegment<String> myArrSegAll = new ArraySegment<String>( myArr );

      // Display the contents of the ArraySegment.
      Console.WriteLine( "The first array segment (with all the array's elements) contains:" );
      PrintIndexAndValues( myArrSegAll );

      // Define an array segment that contains the middle five values of the array.
      ArraySegment<String> myArrSegMid = new ArraySegment<String>( myArr, 2, 5 );

      // Display the contents of the ArraySegment.
      Console.WriteLine( "The second array segment (with the middle five elements) contains:" );
      PrintIndexAndValues( myArrSegMid );

      // Modify the fourth element of the first array segment myArrSegAll.
      myArrSegAll.Array[3] = "LION";

      // Display the contents of the second array segment myArrSegMid.
      // Note that the value of its second element also changed.
      Console.WriteLine( "After the first array segment is modified, the second array segment now contains:" );
      PrintIndexAndValues( myArrSegMid );

   }
 
   public static void PrintIndexAndValues( ArraySegment<String> arrSeg )  {
      for ( int i = arrSeg.Offset; i < (arrSeg.Offset + arrSeg.Count); i++ )  {
         Console.WriteLine( "   [{0}] : {1}", i, arrSeg.Array[i] );
      }
      Console.WriteLine();
   }

   public static void PrintIndexAndValues( String[] myArr )  {
      for ( int i = 0; i < myArr.Length; i++ )  {
         Console.WriteLine( "   [{0}] : {1}", i, myArr[i] );
      }
      Console.WriteLine();
   }

}


/* 
This code produces the following output.

The original array initially contains:
   [0] : The
   [1] : quick
   [2] : brown
   [3] : fox
   [4] : jumps
   [5] : over
   [6] : the
   [7] : lazy
   [8] : dog

The first array segment (with all the array's elements) contains:
   [0] : The
   [1] : quick
   [2] : brown
   [3] : fox
   [4] : jumps
   [5] : over
   [6] : the
   [7] : lazy
   [8] : dog

The second array segment (with the middle five elements) contains:
   [2] : brown
   [3] : fox
   [4] : jumps
   [5] : over
   [6] : the

After the first array segment is modified, the second array segment now contains:
   [2] : brown
   [3] : LION
   [4] : jumps
   [5] : over
   [6] : the

*/

Public Class SamplesArray

    Public Shared Sub Main()

        ' Create and initialize a new string array.
        Dim myArr As String() =  {"The", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"}

        ' Display the initial contents of the array.
        Console.WriteLine("The original array initially contains:")
        PrintIndexAndValues(myArr)

        ' Define an array segment that contains the entire array.
        Dim myArrSegAll As New ArraySegment(Of String)(myArr)

        ' Display the contents of the ArraySegment.
        Console.WriteLine("The first array segment (with all the array's elements) contains:")
        PrintIndexAndValues(myArrSegAll)

        ' Define an array segment that contains the middle five values of the array.
        Dim myArrSegMid As New ArraySegment(Of String)(myArr, 2, 5)

        ' Display the contents of the ArraySegment.
        Console.WriteLine("The second array segment (with the middle five elements) contains:")
        PrintIndexAndValues(myArrSegMid)

        ' Modify the fourth element of the first array segment myArrSegAll.
        myArrSegAll.Array(3) = "LION"

        ' Display the contents of the second array segment myArrSegMid.
        ' Note that the value of its second element also changed.
        Console.WriteLine("After the first array segment is modified, the second array segment now contains:")
        PrintIndexAndValues(myArrSegMid)

    End Sub

    Public Shared Sub PrintIndexAndValues(arrSeg As ArraySegment(Of String))
        Dim i As Integer
        For i = arrSeg.Offset To (arrSeg.Offset + arrSeg.Count - 1)
            Console.WriteLine("   [{0}] : {1}", i, arrSeg.Array(i))
        Next i
        Console.WriteLine()
    End Sub

    Public Shared Sub PrintIndexAndValues(myArr as String())
        Dim i As Integer
        For i = 0 To (myArr.Length - 1)
            Console.WriteLine("   [{0}] : {1}", i, myArr(i))
        Next i
        Console.WriteLine()
    End Sub

End Class


'This code produces the following output.
'
'The original array initially contains:
'   [0] : The
'   [1] : quick
'   [2] : brown
'   [3] : fox
'   [4] : jumps
'   [5] : over
'   [6] : the
'   [7] : lazy
'   [8] : dog
'
'The first array segment (with all the array's elements) contains:
'   [0] : The
'   [1] : quick
'   [2] : brown
'   [3] : fox
'   [4] : jumps
'   [5] : over
'   [6] : the
'   [7] : lazy
'   [8] : dog
'
'The second array segment (with the middle five elements) contains:
'   [2] : brown
'   [3] : fox
'   [4] : jumps
'   [5] : over
'   [6] : the
'
'After the first array segment is modified, the second array segment now contains:
'   [2] : brown
'   [3] : LION
'   [4] : jumps
'   [5] : over
'   [6] : the

Hinweise

ArraySegment<T> ist ein Wrapper um ein Array, das einen Bereich von Elementen in diesem Array begrenzt.ArraySegment<T> is a wrapper around an array that delimits a range of elements in that array. Mehrere ArraySegment<T>-Instanzen können auf dasselbe ursprüngliche Array verweisen und sich überlappen.Multiple ArraySegment<T> instances can refer to the same original array and can overlap. Das ursprüngliche Array muss eindimensional sein und muss über eine Null basierte Indizierung verfügen.The original array must be one-dimensional and must have zero-based indexing.

Hinweis

ArraySegment<T> implementiert die IReadOnlyCollection<T>-Schnittstelle, beginnend mit dem .NET Framework 4.6.NET Framework 4.6; in früheren Versionen der .NET Framework wurde diese Schnittstelle von der ArraySegment<T>-Struktur nicht implementiert.ArraySegment<T> implements the IReadOnlyCollection<T> interface starting with the .NET Framework 4.6.NET Framework 4.6; in previous versions of the .NET Framework, the ArraySegment<T> structure did not implement this interface.

Die ArraySegment<T>-Struktur ist nützlich, wenn die Elemente eines Arrays in unterschiedlichen Segmenten manipuliert werden.The ArraySegment<T> structure is useful whenever the elements of an array will be manipulated in distinct segments. Beispiel:For example:

  • Sie können ein ArraySegment<T>-Objekt, das nur einen Teil eines Arrays darstellt, als Argument an eine Methode übergeben, anstatt eine relativ teure Methode wie Copy aufzurufen, um eine Kopie eines Teils eines Arrays zu übergeben.You can pass an ArraySegment<T> object that represents only a portion of an array as an argument to a method, rather than call a relatively expensive method like Copy to pass a copy of a portion of an array.

  • In einer Multithread-App können Sie die ArraySegment<T>-Struktur verwenden, damit jeder Thread nur für einen Teil des Arrays funktioniert.In a multithreaded app, you can use the ArraySegment<T> structure to have each thread operate on only a portion of the array.

  • Bei aufgabenbasierten asynchronen Vorgängen können Sie ein ArraySegment<T>-Objekt verwenden, um sicherzustellen, dass jede Aufgabe mit einem unterschiedlichen Segment des Arrays arbeitet.For task-based asynchronous operations, you can use an ArraySegment<T> object to ensure that each task operates on a distinct segment of the array. Im folgenden Beispiel wird ein Array in einzelne Segmente mit bis zu zehn Elementen aufgeteilt.The following example divides an array into individual segments with up to ten elements. Jedes Element im Segment wird mit seiner Segment Nummer multipliziert.Each element in the segment is multiplied by its segment number. Das Ergebnis zeigt, dass durch die Verwendung der ArraySegment<T>-Klasse zum Bearbeiten von Elementen auf diese Weise die Werte des zugrunde liegenden Arrays geändert werden.The result shows that using the ArraySegment<T> class to manipulate elements in this way changes the values of its underlying array.

    using System;
    using System.Collections.Generic;
    using System.Threading.Tasks;
    
    public class Example
    {
       private const int segmentSize = 10;
       
       public static async Task Main()
       {
          List<Task> tasks = new List<Task>();
    
          // Create array.
          int[] arr = new int[50];
          for (int ctr = 0; ctr <= arr.GetUpperBound(0); ctr++)
             arr[ctr] = ctr + 1;
    
          // Handle array in segments of 10.
          for (int ctr = 1; ctr <= Math.Ceiling(((double)arr.Length)/segmentSize); ctr++) {
             int multiplier = ctr;
             int elements = (multiplier - 1) * 10 + segmentSize > arr.Length ?
                             arr.Length - (multiplier - 1) * 10 : segmentSize;
             ArraySegment<int> segment = new ArraySegment<int>(arr, (ctr - 1) * 10, elements);
             tasks.Add(Task.Run( () => { IList<int> list = (IList<int>) segment;
                                         for (int index = 0; index < list.Count; index++)
                                            list[index] = list[index] * multiplier;
                                       } ));
          }
          try {
             await Task.WhenAll(tasks.ToArray());
             int elementsShown = 0;
             foreach (var value in arr) {
                Console.Write("{0,3} ", value);
                elementsShown++;
                if (elementsShown % 18 == 0)
                   Console.WriteLine();
             }
          }
          catch (AggregateException e) {
             Console.WriteLine("Errors occurred when working with the array:");
             foreach (var inner in e.InnerExceptions)
                Console.WriteLine("{0}: {1}", inner.GetType().Name, inner.Message);
          }
       }
    }
    // The example displays the following output:
    //      1   2   3   4   5   6   7   8   9  10  22  24  26  28  30  32  34  36
    //     38  40  63  66  69  72  75  78  81  84  87  90 124 128 132 136 140 144
    //    148 152 156 160 205 210 215 220 225 230 235 240 245 250
    
    Imports System.Collections.Generic
    Imports System.Threading.Tasks
    
    Module Example
      Private Const SegmentSize As Integer = 10
      
       Public Sub Main()
          Dim tasks As New List(Of Task)
          
           ' Create array.
          Dim arr(49) As Integer
          For ctr As Integer = 0 To arr.GetUpperBound(0)
             arr(ctr) = ctr + 1
          Next
    
          ' Handle array in segments of 10.
          For ctr As Integer = 1 To CInt(Math.Ceiling(arr.Length / segmentSize))
             Dim multiplier As Integer = ctr
             Dim elements As Integer = If((multiplier - 1) * 10 + segmentSize > arr.Length,
                                          arr.Length - (multiplier - 1) * 10,
                                          segmentSize)
             Dim segment As New ArraySegment(Of Integer)(arr, (ctr - 1) * 10, elements)
             tasks.Add(Task.Run( Sub()
                                    Dim list As IList(Of Integer) = CType(segment, IList(Of Integer))
                                    For index As Integer = 0 To list.Count - 1
                                       list(index) = list(index) * multiplier
                                    Next
                                 End Sub ))
          Next
          Try
             Task.WaitAll(tasks.ToArray())
             Dim elementsShown As Integer = 0
             For Each value In arr
                Console.Write("{0,3} ", value)
                elementsShown += 1
                If elementsShown Mod 18 = 0 Then Console.WriteLine()
             Next
          Catch e As AggregateException
             Console.WriteLine("Errors occurred when working with the array:")
             For Each inner As Exception In e.InnerExceptions
                Console.WriteLine("{0}: {1}", inner.GetType().Name, inner.Message)
             Next
          End Try
       End Sub
    End Module
    ' The example displays the following output:
    '         1   2   3   4   5   6   7   8   9  10  22  24  26  28  30  32  34  36
    '        38  40  63  66  69  72  75  78  81  84  87  90 124 128 132 136 140 144
    '       148 152 156 160 205 210 215 220 225 230 235 240 245 250
    

Beachten Sie jedoch, dass die Segmente nicht vollständig voneinander unabhängig sind, obwohl die ArraySegment<T>-Struktur verwendet werden kann, um ein Array in verschiedene Segmente aufzuteilen.Note, however, that although the ArraySegment<T> structure can be used to divide an array into distinct segments, the segments are not completely independent of one another. Die Array-Eigenschaft gibt das gesamte ursprüngliche Array und keine Kopie des Arrays zurück. aus diesem Grund werden Änderungen an dem Array, das von der Array-Eigenschaft zurückgegeben wird, an das ursprüngliche Array vorgenommen.The Array property returns the entire original array, not a copy of the array; therefore, changes made to the array returned by the Array property are made to the original array. Wenn dies nicht erwünscht ist, sollten Sie Vorgänge für eine Kopie des Arrays anstelle eines ArraySegment<T>-Objekts durchführen, das einen Teil des Arrays darstellt.If this is undesirable, you should perform operations on a copy of the array, rather than an ArraySegment<T> object that represents a portion of the array.

Die Equals-Methode und die Gleichheits-und Ungleichheits Operatoren prüfen auf Verweis Gleichheit, wenn zwei ArraySegment<T>-Objekte verglichen werden.The Equals method and the equality and inequality operators test for reference equality when they compare two ArraySegment<T> objects. Damit zwei ArraySegment<T>-Objekte als gleich betrachtet werden, müssen Sie alle der folgenden Bedingungen erfüllen:For two ArraySegment<T> objects to be considered equal, they must meet all of the following conditions:

  • Verweisen auf dasselbe Array.Reference the same array.

  • Beginnen Sie mit dem gleichen Index im Array.Begin at the same index in the array.

  • Die gleiche Anzahl von Elementen haben.Have the same number of elements.

Wenn Sie ein Element über den Index im ArraySegment<T>-Objekt abrufen möchten, müssen Sie es in ein IList<T>-Objekt umwandeln und es abrufen oder mithilfe der IList<T>.Item[Int32]-Eigenschaft ändern.If you want to retrieve an element by its index in the ArraySegment<T> object, you must cast it to an IList<T> object and retrieve it or modify it by using the IList<T>.Item[Int32] property. Im folgenden Beispiel wird das-Element in einem ArraySegment<T>-Objekt abgerufen, das einen Abschnitt eines Zeichen folgen Arrays begrenzt.The following example retrieves the element in an ArraySegment<T> object that delimits a section of a string array.

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      String[] names = { "Adam", "Bruce", "Charles", "Daniel", 
                         "Ebenezer", "Francis", "Gilbert", 
                         "Henry", "Irving", "John", "Karl",
                         "Lucian", "Michael" };
      var partNames = new ArraySegment<String>(names, 2, 5);
      
      // Cast the ArraySegment object to an IList<String> and enumerate it.
      var list = (IList<String>) partNames;
      for (int ctr = 0; ctr <= list.Count - 1; ctr++)
         Console.WriteLine(list[ctr]);
   }
}
// The example displays the following output:
//    Charles
//    Daniel
//    Ebenezer
//    Francis
//    Gilbert
Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim names() As String = { "Adam", "Bruce", "Charles", "Daniel", 
                                "Ebenezer", "Francis", "Gilbert", 
                                "Henry", "Irving", "John", "Karl",
                                "Lucian", "Michael" }
      Dim partNames As New ArraySegment(Of String)(names, 2, 5)
      
      ' Cast the ArraySegment object to an IList<String> and enumerate it.
      Dim list = CType(partNames, IList(Of String))
      For ctr As Integer = 0 To list.Count - 1
         Console.WriteLine(list(ctr))
      Next     
   End Sub
End Module
' The example displays the following output:
'    Charles
'    Daniel
'    Ebenezer
'    Francis
'    Gilbert

Konstruktoren

ArraySegment<T>(T[])

Initialisiert eine neue Instanz der ArraySegment<T>-Struktur, die alle Elemente im angegebenen Array begrenzt.Initializes a new instance of the ArraySegment<T> structure that delimits all the elements in the specified array.

ArraySegment<T>(T[], Int32, Int32)

Initialisiert eine neue Instanz der ArraySegment<T>-Struktur, die den angegebenen Bereich der Elemente im angegebenen Array begrenzt.Initializes a new instance of the ArraySegment<T> structure that delimits the specified range of the elements in the specified array.

Eigenschaften

Array

Ruft das ursprüngliche Array ab, das den Bereich von Elementen enthält, die das Arraysegment begrenzen.Gets the original array containing the range of elements that the array segment delimits.

Count

Ruft die Anzahl von Elementen im Bereich ab, der vom Arraysegment begrenzt wird.Gets the number of elements in the range delimited by the array segment.

Empty
Item[Int32]

Ruft das Element am angegebenen Index ab oder legt dieses fest.Gets or sets the element at the specified index.

Offset

Ruft die Position des ersten Elements im Bereich, der durch das Arraysegment begrenzt wird, relativ zum Anfang des ursprünglichen Arrays ab.Gets the position of the first element in the range delimited by the array segment, relative to the start of the original array.

Methoden

CopyTo(ArraySegment<T>)
CopyTo(T[])
CopyTo(T[], Int32)
Equals(ArraySegment<T>)

Bestimmt, ob die angegebene ArraySegment<T>-Struktur und die aktuelle Instanz gleich sind.Determines whether the specified ArraySegment<T> structure is equal to the current instance.

Equals(Object)

Bestimmt, ob das angegebene Objekt mit der aktuellen Instanz identisch ist.Determines whether the specified object is equal to the current instance.

GetEnumerator()

Gibt einen Enumerator zurück, mit dem das Arraysegment durchlaufen werden kann.Returns an enumerator that can be used to iterate through the array segment.

GetHashCode()

Gibt den Hashcode für die aktuelle Instanz zurück.Returns the hash code for the current instance.

Slice(Int32)
Slice(Int32, Int32)
ToArray()

Kopiert die Inhalte dieses Arraysegments in ein neues Array.Copies the contents of this array segment into a new array.

Operatoren

Equality(ArraySegment<T>, ArraySegment<T>)

Gibt an, ob zwei ArraySegment<T>-Strukturen gleich sind.Indicates whether two ArraySegment<T> structures are equal.

Implicit(T[] to ArraySegment<T>)
Inequality(ArraySegment<T>, ArraySegment<T>)

Gibt an, ob zwei ArraySegment<T>-Strukturen ungleich sind.Indicates whether two ArraySegment<T> structures are unequal.

Explizite Schnittstellenimplementierungen

ICollection<T>.Add(T)

Löst in allen Fällen eine NotSupportedException-Ausnahme aus.Throws a NotSupportedException exception in all cases.

ICollection<T>.Clear()

Löst in allen Fällen eine NotSupportedException-Ausnahme aus.Throws a NotSupportedException exception in all cases.

ICollection<T>.Contains(T)

Bestimmt, ob das Arraysegment einen bestimmten Wert enthält.Determines whether the array segment contains a specific value.

ICollection<T>.CopyTo(T[], Int32)

Kopiert die Elemente des Arraysegment in ein Array, wobei an einem angegebenen Arrayindex begonnen wird.Copies the elements of the array segment to an array, starting at the specified array index.

ICollection<T>.IsReadOnly

Ruft einen Wert ab, der angibt, ob das Arraysegment schreibgeschützt ist.Gets a value that indicates whether the array segment is read-only.

ICollection<T>.Remove(T)

Löst in allen Fällen eine NotSupportedException-Ausnahme aus.Throws a NotSupportedException exception in all cases.

IEnumerable.GetEnumerator()

Gibt einen Enumerator zurück, der ein Arraysegment durchläuft.Returns an enumerator that iterates through an array segment.

IEnumerable<T>.GetEnumerator()

Gibt einen Enumerator zurück, der das Arraysegment durchläuft.Returns an enumerator that iterates through the array segment.

IList<T>.IndexOf(T)

Bestimmt den Index eines bestimmten Elements im Arraysegment.Determines the index of a specific item in the array segment.

IList<T>.Insert(Int32, T)

Löst in allen Fällen eine NotSupportedException-Ausnahme aus.Throws a NotSupportedException exception in all cases.

IList<T>.Item[Int32]

Ruft das Element am angegebenen Index ab oder legt dieses fest.Gets or sets the element at the specified index.

IList<T>.RemoveAt(Int32)

Löst in allen Fällen eine NotSupportedException-Ausnahme aus.Throws a NotSupportedException exception in all cases.

IReadOnlyList<T>.Item[Int32]

Ruft das Element am angegebenen Index des angegebenen Arraysegments ab.Gets the element at the specified index of the array segment.

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.Returns a DataTable that contains copies of the DataRow objects, given an input IEnumerable<T> object where the generic parameter T is DataRow.

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.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

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.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable)

Wandelt die Elemente eines IEnumerable in den angegebenen Typ umCasts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtert die Elemente eines IEnumerable anhand eines angegebenen TypsFilters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Ermöglicht die Parallelisierung einer Abfrage.Enables parallelization of a query.

AsQueryable(IEnumerable)

Konvertiert einen IEnumerable in einen IQueryable.Converts an IEnumerable to an IQueryable.

AsMemory<T>(ArraySegment<T>)

Erstellt einen neuen Speicherbereich über dem Abschnitt des Zielarraysegments.Creates a new memory region over the portion of the target array segment.

AsMemory<T>(ArraySegment<T>, Int32)

Erstellt einen neuen Speicherbereich über dem Abschnitt des Zielarraysegments, beginnend an einer angegebenen Position bis zum Ende des Segments.Creates a new memory region over the portion of the target array segment starting at a specified position to the end of the segment.

AsMemory<T>(ArraySegment<T>, Int32, Int32)

Erstellt einen neuen Speicherbereich über dem Abschnitt des Zielarraysegments, beginnend an einer angegebenen Position mit einer angegebenen Länge.Creates a new memory region over the portion of the target array segment beginning at a specified position with a specified length.

AsSpan<T>(ArraySegment<T>)

Erstellt eine neue Spanne über einem Zielarraysegment.Creates a new span over a target array segment.

AsSpan<T>(ArraySegment<T>, Index)

Erstellt eine neue Spanne über einem Abschnitt des Zielarraysegments, beginnend mit einem angegebenen Index und endend mit dem Segmentende.Creates a new span over a portion of the target array segment beginning at a specified index and ending at the end of the segment.

AsSpan<T>(ArraySegment<T>, Int32)

Erstellt eine neue Spanne über einem Abschnitt eines Zielarraysegments von einer bestimmten Position aus bis zum Segmentende.Creates a new span over a portion of a target array segment from a specified position to the end of the segment.

AsSpan<T>(ArraySegment<T>, Int32, Int32)

Erstellt eine neue Spanne über einem Abschnitt eines Zielarraysegments von einer bestimmten Position aus für eine angegebene Länge.Creates a new span over a portion of a target array segment from a specified position for a specified length.

AsSpan<T>(ArraySegment<T>, Range)

Erstellt eine neue Spanne über einem Abschnitt eines Zielarraysegments unter Verwendung der Start- und Endindizes des Bereichs.Creates a new span over a portion of a target array segment using the range start and end indexes.

Ancestors<T>(IEnumerable<T>)

Gibt eine Auflistung von Elementen zurück, die die übergeordneten Elemente der einzelnen Knoten in der Quellauflistung enthält.Returns a collection of elements that contains the ancestors of every node in the source collection.

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.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Nur Elemente, die über einen übereinstimmenden XName verfügen, sind in der Auflistung enthalten.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Gibt eine Auflistung der Nachfolgerknoten jedes Dokuments und Elements in der Quellauflistung zurück.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Gibt eine Auflistung von Elementen zurück, die die Nachfolgerelemente jedes Elements und Dokuments in der Quellauflistung enthält.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

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.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Nur Elemente, die über einen übereinstimmenden XName verfügen, sind in der Auflistung enthalten.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Gibt eine Auflistung der untergeordneten Elemente jedes Elements und Dokuments in der Quellauflistung zurück.Returns a collection of the child elements of every element and document in the source collection.

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

Gibt eine gefilterte Auflistung der untergeordneten Elemente jedes Elements und Dokuments in der Quellauflistung zurück.Returns a filtered collection of the child elements of every element and document in the source collection. Nur Elemente, die über einen übereinstimmenden XName verfügen, sind in der Auflistung enthalten.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Gibt eine in Dokumentreihenfolge sortierte Auflistung von Knoten zurück, die alle Knoten in der Quellauflistung enthält.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Gibt eine Auflistung der untergeordneten Knoten jedes Dokuments und Elements in der Quellauflistung zurück.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Entfernt jeden Knoten in der Quellauflistung aus seinem übergeordneten Knoten.Removes every node in the source collection from its parent node.

Gilt für:

Siehe auch