ArraySegment<T> Struct

Definizione

Delimita una sezione di una matrice unidimensionale.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)

Parametri di tipo

T

Tipo di elementi contenuti nel segmento di matrice.The type of the elements in the array segment.

Ereditarietà
ArraySegment<T>
Attributi
Implementazioni

Esempi

Nell'esempio di codice seguente una struttura ArraySegment<T> viene passata a un metodo.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

Commenti

ArraySegment<T> è un wrapper intorno a una matrice che delimita un intervallo di elementi nella matrice.ArraySegment<T> is a wrapper around an array that delimits a range of elements in that array. Più istanze ArraySegment<T> possono fare riferimento alla stessa matrice originale e possono sovrapporsi.Multiple ArraySegment<T> instances can refer to the same original array and can overlap. La matrice originale deve essere unidimensionale e deve avere un'indicizzazione in base zero.The original array must be one-dimensional and must have zero-based indexing.

Nota

ArraySegment<T> implementa l'interfaccia IReadOnlyCollection<T> a partire da .NET Framework 4.6.NET Framework 4.6; nelle versioni precedenti del .NET Framework la struttura ArraySegment<T> non ha implementato questa interfaccia.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.

La struttura ArraySegment<T> è utile ogni volta che gli elementi di una matrice verranno modificati in segmenti distinti.The ArraySegment<T> structure is useful whenever the elements of an array will be manipulated in distinct segments. Ad esempio:For example:

  • È possibile passare un oggetto ArraySegment<T> che rappresenta solo una parte di una matrice come argomento a un metodo, anziché chiamare un metodo relativamente costoso come Copy per passare una copia di una parte di una matrice.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 un'app multithreading, è possibile usare la struttura ArraySegment<T> per fare in modo che ogni thread operi solo su una parte della matrice.In a multithreaded app, you can use the ArraySegment<T> structure to have each thread operate on only a portion of the array.

  • Per le operazioni asincrone basate su attività, è possibile usare un oggetto ArraySegment<T> per assicurarsi che ogni attività funzioni su un segmento distinto della matrice.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. Nell'esempio seguente viene divisa una matrice in singoli segmenti con fino a dieci elementi.The following example divides an array into individual segments with up to ten elements. Ogni elemento del segmento viene moltiplicato per il numero di segmento.Each element in the segment is multiplied by its segment number. Il risultato mostra che l'uso della classe ArraySegment<T> per modificare gli elementi in questo modo modifica i valori della relativa matrice sottostante.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
    

Si noti, tuttavia, che sebbene la struttura ArraySegment<T> possa essere utilizzata per dividere una matrice in segmenti distinti, i segmenti non sono completamente indipendenti l'uno dall'altro.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. La proprietà Array restituisce l'intera matrice originale, non una copia della matrice; Pertanto, le modifiche apportate alla matrice restituita dalla proprietà Array vengono apportate alla matrice originale.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. Se questa operazione non è auspicabile, è consigliabile eseguire operazioni su una copia della matrice, anziché un oggetto ArraySegment<T> che rappresenta una parte della matrice.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.

Il metodo Equals e gli operatori di uguaglianza e disuguaglianza verificano l'uguaglianza dei riferimenti quando confrontano due oggetti ArraySegment<T>.The Equals method and the equality and inequality operators test for reference equality when they compare two ArraySegment<T> objects. Per considerare uguali due oggetti ArraySegment<T>, è necessario che soddisfino tutte le condizioni seguenti:For two ArraySegment<T> objects to be considered equal, they must meet all of the following conditions:

  • Fare riferimento alla stessa matrice.Reference the same array.

  • Inizia con lo stesso indice nella matrice.Begin at the same index in the array.

  • Hanno lo stesso numero di elementi.Have the same number of elements.

Se si desidera recuperare un elemento in base al relativo indice nell'oggetto ArraySegment<T>, è necessario eseguirne il cast a un oggetto IList<T> e recuperarlo o modificarlo utilizzando la proprietà IList<T>.Item[Int32].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. Nell'esempio seguente viene recuperato l'elemento in un oggetto ArraySegment<T> che delimita una sezione di una matrice di stringhe.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

Costruttori

ArraySegment<T>(T[])

Inizializza una nuova istanza della struttura ArraySegment<T> che delimita tutti gli elementi nella matrice specificata.Initializes a new instance of the ArraySegment<T> structure that delimits all the elements in the specified array.

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

Inizializza una nuova istanza della struttura ArraySegment<T> che delimita l'intervallo di elementi specificato nella matrice specificata.Initializes a new instance of the ArraySegment<T> structure that delimits the specified range of the elements in the specified array.

Proprietà

Array

Ottiene la matrice originale contenente l'intervallo di elementi delimitati dal segmento di matrice.Gets the original array containing the range of elements that the array segment delimits.

Count

Ottiene il numero di elementi nell'intervallo delimitato dal segmento di matrice.Gets the number of elements in the range delimited by the array segment.

Empty
Item[Int32]

Ottiene o imposta l'elemento in corrispondenza dell'indice specificato.Gets or sets the element at the specified index.

Offset

Ottiene la posizione del primo elemento nell'intervallo delimitato dal segmento di matrice, relativa all'inizio della matrice originale.Gets the position of the first element in the range delimited by the array segment, relative to the start of the original array.

Metodi

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

Determina se la struttura ArraySegment<T> specificata è uguale all'istanza corrente.Determines whether the specified ArraySegment<T> structure is equal to the current instance.

Equals(Object)

Determina se l'oggetto specificato è uguale all'istanza corrente.Determines whether the specified object is equal to the current instance.

GetEnumerator()

Restituisce un enumeratore utilizzabile per scorrere gli elementi del segmento di matrice.Returns an enumerator that can be used to iterate through the array segment.

GetHashCode()

Restituisce il codice hash per l'istanza corrente.Returns the hash code for the current instance.

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

Copia il contenuto di questo segmento di matrice in una nuova matrice.Copies the contents of this array segment into a new array.

Operatori

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

Indica se due strutture ArraySegment<T> sono uguali.Indicates whether two ArraySegment<T> structures are equal.

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

Indica se due strutture ArraySegment<T> non sono uguali.Indicates whether two ArraySegment<T> structures are unequal.

Implementazioni dell'interfaccia esplicita

ICollection<T>.Add(T)

Genera un'eccezione NotSupportedException in tutti i casi.Throws a NotSupportedException exception in all cases.

ICollection<T>.Clear()

Genera un'eccezione NotSupportedException in tutti i casi.Throws a NotSupportedException exception in all cases.

ICollection<T>.Contains(T)

Stabilisce se il segmento di matrice contiene un valore specifico.Determines whether the array segment contains a specific value.

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

Copia gli elementi del segmento di matrice in una matrice, iniziando dall'indice di matrice specificato.Copies the elements of the array segment to an array, starting at the specified array index.

ICollection<T>.IsReadOnly

Ottiene un valore che indica se il segmento di matrice è di sola lettura.Gets a value that indicates whether the array segment is read-only.

ICollection<T>.Remove(T)

Genera un'eccezione NotSupportedException in tutti i casi.Throws a NotSupportedException exception in all cases.

IEnumerable.GetEnumerator()

Restituisce un enumeratore che consente di scorrere un segmento di matrice.Returns an enumerator that iterates through an array segment.

IEnumerable<T>.GetEnumerator()

Restituisce un enumeratore che consente di scorrere il segmento di matrice.Returns an enumerator that iterates through the array segment.

IList<T>.IndexOf(T)

Consente di determinare l'indice di un elemento specifico nel segmento di matrice.Determines the index of a specific item in the array segment.

IList<T>.Insert(Int32, T)

Genera un'eccezione NotSupportedException in tutti i casi.Throws a NotSupportedException exception in all cases.

IList<T>.Item[Int32]

Ottiene o imposta l'elemento in corrispondenza dell'indice specificato.Gets or sets the element at the specified index.

IList<T>.RemoveAt(Int32)

Genera un'eccezione NotSupportedException in tutti i casi.Throws a NotSupportedException exception in all cases.

IReadOnlyList<T>.Item[Int32]

Ottiene l'elemento in corrispondenza dell'indice specificato del segmento di matrice.Gets the element at the specified index of the array segment.

Metodi di estensione

CopyToDataTable<T>(IEnumerable<T>)

Restituisce un oggetto DataTable che contiene copie degli oggetti DataRow, dato un oggetto IEnumerable<T> di input dove il parametro generico DataRow è T.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)

Copia gli oggetti DataRow nell'oggetto DataTable specificato, dato un oggetto IEnumerable<T> di input dove il parametro generico T è DataRow.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)

Copia gli oggetti DataRow nell'oggetto DataTable specificato, dato un oggetto IEnumerable<T> di input dove il parametro generico T è DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable)

Esegue il cast degli elementi di un oggetto IEnumerable nel tipo specificato.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtra gli elementi di un oggetto IEnumerable in base a un tipo specificato.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Consente la parallelizzazione di una query.Enables parallelization of a query.

AsQueryable(IEnumerable)

Converte un oggetto IEnumerable in un oggetto IQueryable.Converts an IEnumerable to an IQueryable.

AsMemory<T>(ArraySegment<T>)

Crea una nuova area di memoria sulla parte del segmento della matrice di destinazione.Creates a new memory region over the portion of the target array segment.

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

Crea una nuova area di memoria sulla parte del segmento della matrice di destinazione a partire da una posizione specificata fino alla fine del segmento.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)

Crea una nuova area di memoria sulla parte del segmento della matrice di destinazione a partire da una posizione specificata fino alla lunghezza specificata.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>)

Crea un nuovo intervallo su un segmento della matrice di destinazione.Creates a new span over a target array segment.

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

Crea un nuovo intervallo su una parte del segmento della matrice di destinazione a partire da un indice specificato fino alla fine del segmento.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)

Crea un nuovo intervallo su una parte del segmento della stringa di destinazione da una posizione specificata alla fine del segmento.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)

Crea un nuovo intervallo su una parte del segmento della stringa di destinazione da una posizione specificata per una lunghezza definita.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)

Crea un nuovo intervallo su una parte di un segmento della matrice di destinazione usando gli indici di inizio e di fine dell'intervallo.Creates a new span over a portion of a target array segment using the range start and end indexes.

Ancestors<T>(IEnumerable<T>)

Restituisce una raccolta di elementi che contiene i predecessori di ciascun nodo nella raccolta di origine.Returns a collection of elements that contains the ancestors of every node in the source collection.

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

Restituisce una raccolta di elementi filtrati che contiene i predecessori di ciascun nodo nella raccolta di origine.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Restituisce una raccolta di nodi discendenti di ciascun documento ed elemento nella raccolta di origine.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Restituisce una raccolta di elementi che contiene gli elementi discendenti di ciascun elemento e documento nella raccolta di origine.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

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

Restituisce una raccolta filtrata di elementi che contiene gli elementi discendenti di ciascun elemento e documento nella raccolta di origine.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Restituisce una raccolta di elementi figlio di ciascun elemento e documento nella raccolta di origine.Returns a collection of the child elements of every element and document in the source collection.

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

Restituisce una raccolta filtrata degli elementi figlio di ciascun elemento e documento nella raccolta di origine.Returns a filtered collection of the child elements of every element and document in the source collection. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Restituisce una raccolta di nodi che contiene tutti i nodi nella raccolta di origine ordinati in base all'ordine con cui sono riportati nel documento.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Restituisce una raccolta di nodi figlio di ciascun documento ed elemento nella raccolta di origine.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Rimuove ciascun nodo nella raccolta di origine dal nodo padre.Removes every node in the source collection from its parent node.

Si applica a

Vedi anche