ArraySegment<T> 结构

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>

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

[System.Serializable]
public struct ArraySegment<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>

继承

Object

ValueType

ArraySegment<T>

属性

SerializableAttribute

实现

ICollection<T> IEnumerable<T> IList<T> IReadOnlyCollection<T> IReadOnlyList<T> IEnumerable

下面的代码示例将 ArraySegment<T> 结构传递给方法。

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

*/

ArraySegment<T> 是数组的包装器，用于分隔该数组中的元素范围。 多个 ArraySegment<T> 实例可以引用相同的原始数组，并且可以重叠。 原始数组必须是一维数组，并且必须具有从零开始的索引。

每当数组的元素在不同的段中操作时，ArraySegment<T> 结构都很有用。 例如：

• 可以将仅表示数组的一部分作为参数的 ArraySegment<T> 对象传递给方法，而不是调用相对昂贵的方法（如 Copy）来传递数组的一部分副本。

• 在多线程应用中，可以使用 ArraySegment<T> 结构让每个线程只对数组的一部分进行操作。

• 对于基于任务的异步操作，可以使用 ArraySegment<T> 对象来确保每个任务对数组的不同段进行操作。 以下示例将数组划分为包含最多 10 个元素的单个段。 段中的每个元素都乘以其段号。 结果显示，使用 ArraySegment<T> 类以这种方式操作元素会更改其基础数组的值。

  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
  

但是，请注意，尽管 ArraySegment<T> 结构可用于将数组划分为不同的段，但段并不完全独立于彼此。 Array 属性返回整个原始数组，而不是数组的副本;因此，对 Array 属性返回的数组所做的更改对原始数组进行了更改。 如果这是不可取的，则应对数组的副本执行操作，而不是表示数组一部分的 ArraySegment<T> 对象。

Equals 方法和相等运算符在比较两个 ArraySegment<T> 对象时测试引用相等性。 若要将两个 ArraySegment<T> 对象视为相等，它们必须满足以下所有条件：

• 引用相同的数组。

• 从数组中的同一索引开始。

• 具有相同数量的元素。

如果要在 ArraySegment<T> 对象中按其索引检索元素，则必须将其强制转换为 IList<T> 对象，并使用 IList<T>.Item[] 属性对其进行检索或修改。 请注意，F# 中不需要这样做。 以下示例检索 ArraySegment<T> 对象中的元素，该元素分隔字符串数组的节。

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

• Array