ArraySegment<T> ArraySegment<T> ArraySegment<T> ArraySegment<T> Struct

Definice

Odděluje oddíl jednorozměrného pole.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)

Parametry typu

T

Typ prvků v segmentu Array.The type of the elements in the array segment.

Dědičnost
ArraySegment<T>ArraySegment<T>ArraySegment<T>ArraySegment<T>
Atributy
Implementuje

Příklady

Následující příklad kódu předá ArraySegment<T> strukturu metodě.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

*/

Imports System

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

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

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

End Class 'SamplesArray


'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

Poznámky

ArraySegment<T>je Obálka kolem pole, které omezuje rozsah prvků v daném poli.ArraySegment<T> is a wrapper around an array that delimits a range of elements in that array. Více ArraySegment<T> instancí může odkazovat na stejné původní pole a může se překrývat.Multiple ArraySegment<T> instances can refer to the same original array and can overlap. Původní pole musí být jednorozměrné a musí mít indexování založené na nule.The original array must be one-dimensional and must have zero-based indexing.

Poznámka

ArraySegment<T>implementuje rozhraní začínající na .NET Framework 4.6.NET Framework 4.6; v předchozích verzích .NET Framework ArraySegment<T> struktura neimplementovala toto rozhraní. IReadOnlyCollection<T>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.

ArraySegment<T> Struktura je užitečná vždy, když se prvky pole budou manipulovat v různých segmentech.The ArraySegment<T> structure is useful whenever the elements of an array will be manipulated in distinct segments. Příklad:For example:

  • Můžete předat ArraySegment<T> objekt, který představuje pouze část pole jako argument metody, namísto volání poměrně nákladné metody, jako Copy je předání kopie části pole.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.

  • V aplikaci s více vlákny můžete použít ArraySegment<T> strukturu, aby každé vlákno fungovalo pouze v části pole.In a multithreaded app, you can use the ArraySegment<T> structure to have each thread operate on only a portion of the array.

  • Pro asynchronní operace založené na úlohách můžete použít ArraySegment<T> objekt k zajištění, že každý úkol pracuje na samostatném segmentu pole.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. Následující příklad rozdělí pole do jednotlivých segmentů s až deseti prvky.The following example divides an array into individual segments with up to ten elements. Každý prvek v segmentu vynásobí jeho číslo segmentu.Each element in the segment is multiplied by its segment number. Výsledek ukazuje, že použití ArraySegment<T> třídy pro manipulaci s prvky tímto způsobem změní hodnoty jejich podkladového pole.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
    

Všimněte si ale, že i když ArraySegment<T> se struktura dá použít k rozdělení pole na samostatné segmenty, segmenty nejsou zcela nezávisle na sobě.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. Vlastnost vrací celé původní pole, nikoli kopii pole; proto jsou provedeny změny pole vráceného Array vlastností do původního pole. ArrayThe 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. Pokud je to nežádoucí, měli byste provádět operace na kopii pole, nikoli ArraySegment<T> objekt, který představuje část pole.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.

Metoda a operátory rovnosti a nerovnosti jsou testovány na referenční rovnost při porovnávání dvou ArraySegment<T> objektů. EqualsThe Equals method and the equality and inequality operators test for reference equality when they compare two ArraySegment<T> objects. Pro dva ArraySegment<T> objekty, které mají být považovány za stejné, musí splňovat všechny následující podmínky:For two ArraySegment<T> objects to be considered equal, they must meet all of the following conditions:

  • Odkázat na stejné pole.Reference the same array.

  • Začněte na stejném indexu v poli.Begin at the same index in the array.

  • Má stejný počet prvků.Have the same number of elements.

Chcete-li načíst element podle jeho indexu v ArraySegment<T> objektu, je nutné jej přetypovat IList<T> na objekt a načíst jej nebo jej IList<T>.Item[Int32] upravit pomocí vlastnosti.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. Následující příklad načte prvek v ArraySegment<T> objektu, který omezuje oddíl pole řetězců.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

Konstruktory

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

Inicializuje novou instanci ArraySegment<T> struktury, která omezuje všechny prvky v zadaném poli.Initializes a new instance of the ArraySegment<T> structure that delimits all the elements in the specified array.

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

Inicializuje novou instanci ArraySegment<T> struktury, která omezuje zadaný rozsah prvků v zadaném poli.Initializes a new instance of the ArraySegment<T> structure that delimits the specified range of the elements in the specified array.

Vlastnosti

Array Array Array Array

Získá původní pole obsahující rozsah prvků, které jsou rozděleny segmentem pole.Gets the original array containing the range of elements that the array segment delimits.

Count Count Count Count

Získá počet prvků v rozsahu, který je oddělený segmentem Array.Gets the number of elements in the range delimited by the array segment.

Empty Empty Empty Empty
Item[Int32] Item[Int32] Item[Int32] Item[Int32]
Offset Offset Offset Offset

Získá pozici prvního prvku v rozsahu, který je oddělený segmentem pole, vzhledem k začátku původního pole.Gets the position of the first element in the range delimited by the array segment, relative to the start of the original array.

Metody

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

Určuje, zda je ArraySegment<T> zadaná struktura shodná s aktuální instancí.Determines whether the specified ArraySegment<T> structure is equal to the current instance.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Určuje, zda je zadaný objekt stejný jako aktuální instance.Determines whether the specified object is equal to the current instance.

GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Vrátí kód hodnoty hash aktuální instance.Returns the hash code for the current instance.

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

Operátory

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

Označuje, zda ArraySegment<T> jsou dvě struktury stejné.Indicates whether two ArraySegment<T> structures are equal.

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

Označuje, zda ArraySegment<T> se dvě struktury neshodují.Indicates whether two ArraySegment<T> structures are unequal.

Explicitní implementace rozhraní

ICollection<T>.Add(T) ICollection<T>.Add(T) ICollection<T>.Add(T) ICollection<T>.Add(T)

Přidá položku do segmentu Array.Adds an item to the array segment.

ICollection<T>.Clear() ICollection<T>.Clear() ICollection<T>.Clear() ICollection<T>.Clear()

Odebere všechny položky ze segmentu Array.Removes all items from the array segment.

ICollection<T>.Contains(T) ICollection<T>.Contains(T) ICollection<T>.Contains(T) ICollection<T>.Contains(T)

Určuje, zda segment pole obsahuje konkrétní hodnotu.Determines whether the array segment contains a specific value.

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

Zkopíruje prvky segmentu Array do pole, počínaje zadaným indexem pole.Copies the elements of the array segment to an array, starting at the specified array index.

ICollection<T>.IsReadOnly ICollection<T>.IsReadOnly ICollection<T>.IsReadOnly ICollection<T>.IsReadOnly

Získá hodnotu, která označuje, zda je segment pole určen jen pro čtení.Gets a value that indicates whether the array segment is read-only.

ICollection<T>.Remove(T) ICollection<T>.Remove(T) ICollection<T>.Remove(T) ICollection<T>.Remove(T)

Odebere první výskyt konkrétního objektu ze segmentu Array.Removes the first occurrence of a specific object from the array segment.

IEnumerable<T>.GetEnumerator() IEnumerable<T>.GetEnumerator() IEnumerable<T>.GetEnumerator() IEnumerable<T>.GetEnumerator()

Vrátí enumerátor, který projde segment Array.Returns an enumerator that iterates through the array segment.

IList<T>.IndexOf(T) IList<T>.IndexOf(T) IList<T>.IndexOf(T) IList<T>.IndexOf(T)

Určuje index určité položky v segmentu pole.Determines the index of a specific item in the array segment.

IList<T>.Insert(Int32, T) IList<T>.Insert(Int32, T) IList<T>.Insert(Int32, T) IList<T>.Insert(Int32, T)

Vloží položku do segmentu pole v zadaném indexu.Inserts an item into the array segment at the specified index.

IList<T>.Item[Int32] IList<T>.Item[Int32] IList<T>.Item[Int32] IList<T>.Item[Int32]

Získá nebo nastaví prvek na zadaný index.Gets or sets the element at the specified index.

IList<T>.RemoveAt(Int32) IList<T>.RemoveAt(Int32) IList<T>.RemoveAt(Int32) IList<T>.RemoveAt(Int32)

Odebere položku segmentu pole v zadaném indexu.Removes the array segment item at the specified index.

IReadOnlyList<T>.Item[Int32] IReadOnlyList<T>.Item[Int32] IReadOnlyList<T>.Item[Int32] IReadOnlyList<T>.Item[Int32]

Získá prvek na zadaném indexu segmentu pole.Gets the element at the specified index of the array segment.

IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator()

Vrátí enumerátor, který prochází segmentem pole.Returns an enumerator that iterates through an array segment.

Metody rozšíření

CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>)

IEnumerable<T> DataRow T Vrátí, který obsahuje kopie DataRow objektů, a to tak, že předané vstupní objekt, kde je obecný parametr. DataTableReturns 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) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

Zkopíruje DataRow objekty do zadaného DataTables předaným vstupním IEnumerable<T> objektem, kde T je DataRowobecný parametr.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) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

Zkopíruje DataRow objekty do zadaného DataTables předaným vstupním IEnumerable<T> objektem, kde T je DataRowobecný parametr.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

Přetypování prvky IEnumerable na zadaný typ.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

Filtruje prvky IEnumerable založené na zadaném typu.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

Povoluje paralelní zpracování dotazu.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

IEnumerable PřevedeIQueryablena.Converts an IEnumerable to an IQueryable.

AsMemory<T>(ArraySegment<T>) AsMemory<T>(ArraySegment<T>) AsMemory<T>(ArraySegment<T>) AsMemory<T>(ArraySegment<T>)

Vytvoří novou oblast paměti nad část cílového segmentu Array.Creates a new memory region over the portion of the target array segment.

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

Vytvoří novou oblast paměti nad část cílového segmentu pole počínaje určenou pozicí na konec segmentu.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) AsMemory<T>(ArraySegment<T>, Int32, Int32) AsMemory<T>(ArraySegment<T>, Int32, Int32) AsMemory<T>(ArraySegment<T>, Int32, Int32)

Vytvoří novou oblast paměti nad část cílového segmentu pole začínající na zadané pozici se zadanou délkou.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>) AsSpan<T>(ArraySegment<T>) AsSpan<T>(ArraySegment<T>) AsSpan<T>(ArraySegment<T>)

Vytvoří nový rozsah přes cílový segment pole.Creates a new span over a target array segment.

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

Vytvoří nový rozsah přes část cílového segmentu pole začínající v zadaném indexu a končí na konci segmentu.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) AsSpan<T>(ArraySegment<T>, Int32) AsSpan<T>(ArraySegment<T>, Int32) AsSpan<T>(ArraySegment<T>, Int32)

Vytvoří nový rozsah v rámci části cílového segmentu pole ze zadané pozice na konec segmentu.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) AsSpan<T>(ArraySegment<T>, Int32, Int32) AsSpan<T>(ArraySegment<T>, Int32, Int32) AsSpan<T>(ArraySegment<T>, Int32, Int32)

Vytvoří nový rozsah v rámci části cílového segmentu pole ze zadané pozice pro zadanou délku.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) AsSpan<T>(ArraySegment<T>, Range) AsSpan<T>(ArraySegment<T>, Range) AsSpan<T>(ArraySegment<T>, Range)

Vytvoří nový rozsah přes část cílového segmentu pole pomocí počátečních a koncových indexů rozsahu.Creates a new span over a portion of a target array segment using the range start and end indexes

Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>)

Vrátí kolekci prvků, které obsahují předchůdce všech uzlů ve zdrojové kolekci.Returns a collection of elements that contains the ancestors of every node in the source collection.

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

Vrátí filtrovanou kolekci prvků, které obsahují předchůdce všech uzlů ve zdrojové kolekci.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Do kolekce jsou zahrnuty pouze prvky XName , které mají odpovídající spárování.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>)

Vrátí kolekci podřízených uzlů každého dokumentu a elementu ve zdrojové kolekci.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>)

Vrátí kolekci prvků, které obsahují následníky každého prvku a dokumentu ve zdrojové kolekci.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

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

Vrátí filtrovanou kolekci prvků, které obsahují následníky každého prvku a dokumentu ve zdrojové kolekci.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Do kolekce jsou zahrnuty pouze prvky XName , které mají odpovídající spárování.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>) Elements<T>(IEnumerable<T>) Elements<T>(IEnumerable<T>) Elements<T>(IEnumerable<T>)

Vrátí kolekci podřízených prvků každého prvku a dokumentu ve zdrojové kolekci.Returns a collection of the child elements of every element and document in the source collection.

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

Vrátí filtrovanou kolekci podřízených prvků každého elementu a dokumentu ve zdrojové kolekci.Returns a filtered collection of the child elements of every element and document in the source collection. Do kolekce jsou zahrnuty pouze prvky XName , které mají odpovídající spárování.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>) InDocumentOrder<T>(IEnumerable<T>) InDocumentOrder<T>(IEnumerable<T>) InDocumentOrder<T>(IEnumerable<T>)

Vrátí kolekci uzlů, které obsahují všechny uzly ve zdrojové kolekci seřazené v pořadí dokumentů.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>)

Vrátí kolekci podřízených uzlů každého dokumentu a elementu ve zdrojové kolekci.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>)

Odebere všechny uzly ve zdrojové kolekci z nadřazeného uzlu.Removes every node in the source collection from its parent node.

Platí pro

Viz také