Array.Resize<T>(T[], Int32) Metodo

Definizione

Spazio dei nomi:

System

Assembly:

netstandard.dll, System.Runtime.dll

Origine:

Array.cs

Modifica il numero di elementi di una matrice unidimensionale in una nuova dimensione specificata.

C#

public static void Resize<T>(ref T[]? array, int newSize);

Parametri di tipo

T

Tipo degli elementi della matrice.

Parametri

array

T[]

Matrice in base zero unidimensionale da ridimensionare oppure null per creare una nuova matrice della dimensione specificata.

newSize

Int32

Dimensione della nuova matrice.

Eccezioni

ArgumentOutOfRangeException

newSize è minore di zero.

Esempio

Nell'esempio seguente viene illustrato come il ridimensionamento influisce sulla matrice.

C#

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 values of the array.
        Console.WriteLine(
            "The string array initially contains the following values:");
        PrintIndexAndValues(myArr);

        // Resize the array to a bigger size (five elements larger).
        Array.Resize(ref myArr, myArr.Length + 5);

        // Display the values of the array.
        Console.WriteLine("After resizing to a larger size, ");
        Console.WriteLine("the string array contains the following values:");
        PrintIndexAndValues(myArr);

        // Resize the array to a smaller size (four elements).
        Array.Resize(ref myArr, 4);

        // Display the values of the array.
        Console.WriteLine("After resizing to a smaller size, ");
        Console.WriteLine("the string array contains the following values:");
        PrintIndexAndValues(myArr);
    }

    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 string array initially contains the following values:
   [0] : The
   [1] : quick
   [2] : brown
   [3] : fox
   [4] : jumps
   [5] : over
   [6] : the
   [7] : lazy
   [8] : dog

After resizing to a larger size,
the string array contains the following values:
   [0] : The
   [1] : quick
   [2] : brown
   [3] : fox
   [4] : jumps
   [5] : over
   [6] : the
   [7] : lazy
   [8] : dog
   [9] :
   [10] :
   [11] :
   [12] :
   [13] :

After resizing to a smaller size,
the string array contains the following values:
   [0] : The
   [1] : quick
   [2] : brown
   [3] : fox

*/

Commenti

Questo metodo alloca una nuova matrice con le dimensioni specificate, copia gli elementi dalla matrice precedente a quella nuova e quindi sostituisce la matrice precedente con quella nuova. array deve essere una matrice unidimensionale.

Se array è null, questo metodo crea una nuova matrice con le dimensioni specificate.

Se newSize è maggiore di quello Length della matrice precedente, viene allocata una nuova matrice e tutti gli elementi vengono copiati dalla matrice precedente a quella nuova. Se newSize è minore di quello Length della matrice precedente, viene allocata una nuova matrice e gli elementi vengono copiati dalla matrice precedente a quella nuova fino a quando non viene riempito il nuovo, mentre il resto degli elementi nella matrice precedente viene ignorato. Se newSize è uguale all'oggetto Length della matrice precedente, questo metodo non esegue alcuna operazione.

Questo metodo è un'operazione O(n), dove n è newSize.

Il Resize metodo ridimensiona solo una matrice unidimensionale. La Array classe non include un metodo per ridimensionare le matrici multidimensionali. A tale scopo, è necessario specificare il proprio codice o chiamare un metodo speciale in una libreria di terze parti. Il codice seguente illustra una possibile implementazione per un metodo che ridimensiona una matrice di n dimensioni.

C#

using System;

public class Example
{
   public static void Main()
   {
      int[,] arr = new int[10,2];
      for (int n1 = 0; n1 <= arr.GetUpperBound(0); n1++) {
         arr[n1, 0] = n1;
         arr[n1, 1] = n1 * 2;
      }

      // Make a 2-D array larger in the first dimension.
      arr = (int[,]) ResizeArray(arr, new int[] { 12, 2} );
      for (int ctr = 0; ctr <= arr.GetUpperBound(0); ctr++)
         Console.WriteLine("{0}: {1}, {2}", ctr, arr[ctr, 0], arr[ctr, 1]);
      Console.WriteLine();

      // Make a 2-D array smaller in the first dimension.
      arr = (int[,]) ResizeArray(arr, new int[] { 2, 2} );
      for (int ctr = 0; ctr <= arr.GetUpperBound(0); ctr++)
         Console.WriteLine("{0}: {1}, {2}", ctr, arr[ctr, 0], arr[ctr, 1]);
   }

   private static Array ResizeArray(Array arr, int[] newSizes)
   {
      if (newSizes.Length != arr.Rank)
         throw new ArgumentException("arr must have the same number of dimensions " +
                                     "as there are elements in newSizes", "newSizes");

      var temp = Array.CreateInstance(arr.GetType().GetElementType(), newSizes);
      int length = arr.Length <= temp.Length ? arr.Length : temp.Length;
      Array.ConstrainedCopy(arr, 0, temp, 0, length);
      return temp;
   }
}
// The example displays the following output:
//       0: 0, 0
//       1: 1, 2
//       2: 2, 4
//       3: 3, 6
//       4: 4, 8
//       5: 5, 10
//       6: 6, 12
//       7: 7, 14
//       8: 8, 16
//       9: 9, 18
//       10: 0, 0
//       11: 0, 0
//
//       0: 0, 0
//       1: 1, 2

Si applica a