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

Definizione

Modifica il numero di elementi di una matrice unidimensionale in una nuova dimensione specificata.Changes the number of elements of a one-dimensional array to the specified new size.

public:
generic <typename T>
 static void Resize(cli::array <T> ^ % array, int newSize);
public static void Resize<T> (ref T[] array, int newSize);
static member Resize : T[] * int -> unit
Public Shared Sub Resize(Of T) (ByRef array As T(), newSize As Integer)

Parametri di tipo

T

Tipo degli elementi della matrice.The type of the elements of the array.

Parametri

array
T[]

Matrice in base zero unidimensionale da ridimensionare oppure null per creare una nuova matrice della dimensione specificata.The one-dimensional, zero-based array to resize, or null to create a new array with the specified size.

newSize
Int32

Dimensione della nuova matrice.The size of the new array.

Eccezioni

newSize è minore di zero.newSize is less than zero.

Esempi

Nell'esempio seguente viene illustrato come il ridimensionamento influisca sulla matrice.The following example shows how resizing affects the array.

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

int main()
{
   
    // Create and initialize a new string array.
    array<String^>^myArr = {L"The", L"quick", L"brown", L"fox",
        L"jumps", L"over", L"the", L"lazy", L"dog"};
   
    // Display the values of the array.
    Console::WriteLine( 
        L"The string array initially contains the following values:");
    PrintIndexAndValues(myArr);
   
    // Resize the array to a bigger size (five elements larger).
    Array::Resize(myArr, myArr->Length + 5);
   
    // Display the values of the array.
    Console::WriteLine(L"After resizing to a larger size, ");
    Console::WriteLine(L"the string array contains the following values:");
    PrintIndexAndValues(myArr);
   
    // Resize the array to a smaller size (four elements).
    Array::Resize(myArr, 4);
   
    // Display the values of the array.
    Console::WriteLine(L"After resizing to a smaller size, ");
    Console::WriteLine(L"the string array contains the following values:");
    PrintIndexAndValues(myArr);
    return 1;
}

/* 
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

*/
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

*/
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 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(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(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)

    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 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, quindi sostituisce la matrice precedente con quella nuova.This method allocates a new array with the specified size, copies elements from the old array to the new one, and then replaces the old array with the new one. array deve essere una matrice unidimensionale.array must be a one-dimensional array.

Se array è null, questo metodo crea una nuova matrice con le dimensioni specificate.If array is null, this method creates a new array with the specified size.

Se newSize è maggiore della Length della matrice precedente, viene allocata una nuova matrice e tutti gli elementi vengono copiati dalla matrice precedente a quella nuova.If newSize is greater than the Length of the old array, a new array is allocated and all the elements are copied from the old array to the new one. Se newSize è minore del 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 oggetto; il resto degli elementi nella matrice precedente viene ignorato.If newSize is less than the Length of the old array, a new array is allocated and elements are copied from the old array to the new one until the new one is filled; the rest of the elements in the old array are ignored. Se newSize è uguale alla Length della matrice precedente, questo metodo non esegue alcuna operazione.If newSize is equal to the Length of the old array, this method does nothing.

Questo metodo è un'operazione O (n), in cui n è newSize.This method is an O(n) operation, where n is newSize.

Il metodo Resize ridimensiona una sola matrice unidimensionale.The Resize method resizes a one-dimensional array only. La classe Array non include un metodo per ridimensionare matrici multidimensionali.The Array class does not include a method for resizing multi-dimensional arrays. A tale scopo, è necessario fornire codice personalizzato o chiamare un metodo speciale in una libreria di terze parti.To do this, you must either provide your own code or call a special-purpose method in a third-party library. Nel codice seguente viene illustrata una possibile implementazione per un metodo che ridimensiona una matrice di n dimensioni.The following code illustrates one possible implementation for a method that resizes an array of n dimensions.

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
Module Example
   Public Sub Main()
      Dim arr(9, 1) As Integer
      For n1 As Integer = 0 To arr.GetUpperBound(0)
         arr(n1, 0) = n1
         arr(n1, 1) = n1 * 2
      Next 

      ' Make a 2-D array larger in the first dimension.
      arr = CType(ResizeArray(arr, { 12, 2} ), Integer(,))
      For ctr = 0 To arr.GetUpperBound(0)
         Console.WriteLine("{0}: {1}, {2}", ctr, arr(ctr, 0), arr(ctr, 1))
      Next
      Console.WriteLine()
      
      ' Make a 2-D array smaller in the first dimension.
      arr = CType(ResizeArray(arr, { 2, 2} ), Integer(,))
      For ctr = 0 To arr.GetUpperBound(0)
         Console.WriteLine("{0}: {1}, {2}", ctr, arr(ctr, 0), arr(ctr, 1))
      Next
   End Sub

   Private Function ResizeArray(arr As Array, newSizes() As Integer) As Array
      If newSizes.Length <> arr.Rank Then
         Throw New ArgumentException("arr must have the same number of dimensions " +
                                     "as there are elements in newSizes", "newSizes") 
      End If 

      Dim temp As Array = Array.CreateInstance(arr.GetType().GetElementType(), newSizes)
      Dim length As Integer = If(arr.Length <= temp.Length, arr.Length, temp.Length )
      Array.ConstrainedCopy(arr, 0, temp, 0, length)
      Return temp
   End Function
End Module
' 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