Esporta (0) Stampa
Espandi tutto

Classe Array

Aggiornamento: novembre 2007

Vengono forniti metodi per creare, manipolare, ordinare ed eseguire ricerche all'interno di matrici, diventando così la classe base per tutte le matrici in Common Language Runtime.

Spazio dei nomi:  System
Assembly:  mscorlib (in mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public abstract class Array : ICloneable, 
	IList, ICollection, IEnumerable
/** @attribute SerializableAttribute */ 
/** @attribute ComVisibleAttribute(true) */
public abstract class Array implements ICloneable, 
	IList, ICollection, IEnumerable
public abstract class Array implements ICloneable, IList, ICollection, IEnumerable

La classe Array è la classe base per le implementazioni del linguaggio che supportano le matrici. Tuttavia, soltanto il sistema e i compilatori possono derivare in modo esplicito dalla classe Array. Gli utenti devono utilizzare i costrutti della matrice forniti dal linguaggio.

Un elemento è un valore in un oggetto Array. La lunghezza di un oggetto Array è il numero totale di elementi che può contenere. L'indice di un oggetto Array è il numero di dimensioni nell'oggetto Array. Il limite inferiore di una dimensione di un oggetto Array è l'indice iniziale della dimensione dell'oggetto Array; un oggetto Array multidimensionale può avere limiti che variano per ogni dimensione.

czz5hkty.alert_caution(it-it,VS.90).gifNota importante:

In .NET Framework versione 2.0 la classe Array implementa le interfacce generiche System.Collections.Generic.IList<T>, System.Collections.Generic.ICollection<T> e System.Collections.Generic.IEnumerable<T>. Le implementazioni vengono fornite alle matrici in fase di esecuzione, pertanto non sono visibili negli strumenti di generazione della documentazione. Di conseguenza, le interfacce generiche non vengono visualizzate nella sintassi per la dichiarazione della classe Array e non sono disponibili argomenti di riferimento per i membri dell'interfaccia accessibili solo tramite il cast di una matrice al tipo interfaccia generica (implementazioni esplicite dell'interfaccia). È necessario tenere presente che quando si esegue il cast di una matrice a una di queste interfacce, i membri che aggiungono, inseriscono o rimuovono elementi generano NotSupportedException.

Gli oggetti Type forniscono informazioni relative alle dichiarazioni del tipo matrice. Gli oggetti Array con lo stesso tipo matrice condividono lo stesso oggetto Type.

È possibile che Type.IsArray e Type.GetElementType non restituiscano i risultati previsti Array poiché, se una matrice è impostata sul tipo Array, il risultato sarà un oggetto, non una matrice. Ovvero, typeof(System.Array).IsArray restituirà false e typeof(System.Array).GetElementType restituirà null.

A differenza della maggior parte delle classi, Array fornisce il metodo CreateInstance, anziché i costruttori pubblici, per consentire l'accesso ad associazione tardiva.

Il metodo Array.Copy copia gli elementi non solo tra matrici dello stesso tipo, ma anche tra matrici standard di diversi tipi; gestisce il cast del tipo automaticamente.

Alcuni metodi, come CreateInstance, Copy, CopyTo, GetValue e SetValue, forniscono overload che accettano come parametri valori integer a 64 bit per contenere matrici di grande capacità. La proprietà LongLength e il metodo GetLongLength restituiscono valori integer a 64 bit che indicano la lunghezza della matrice.

Non è garantito che la classe Array sia ordinata. È necessario ordinare la classe Array prima di eseguire operazioni, quali BinarySearch, che richiedono che la classe Array sia ordinata.

Nell'esempio di codice seguente viene illustrato come Array.Copy copia elementi tra una matrice di tipo integer e una matrice di tipo Object.

public class SamplesArray  {

   public static void Main()  {

      // Creates and initializes a new integer array and a new Object array.
      int[] myIntArray = new int[5] { 1, 2, 3, 4, 5 };
      Object[] myObjArray = new Object[5] { 26, 27, 28, 29, 30 };

      // Prints the initial values of both arrays.
      Console.WriteLine( "Initially," );
      Console.Write( "integer array:" );
      PrintValues( myIntArray );
      Console.Write( "Object array: " );
      PrintValues( myObjArray );

      // Copies the first two elements from the integer array to the Object array.
      System.Array.Copy( myIntArray, myObjArray, 2 );

      // Prints the values of the modified arrays.
      Console.WriteLine( "\nAfter copying the first two elements of the integer array to the Object array," );
      Console.Write( "integer array:" );
      PrintValues( myIntArray );
      Console.Write( "Object array: " );
      PrintValues( myObjArray );

      // Copies the last two elements from the Object array to the integer array.
      System.Array.Copy( myObjArray, myObjArray.GetUpperBound(0) - 1, myIntArray, myIntArray.GetUpperBound(0) - 1, 2 );

      // Prints the values of the modified arrays.
      Console.WriteLine( "\nAfter copying the last two elements of the Object array to the integer array," );
      Console.Write( "integer array:" );
      PrintValues( myIntArray );
      Console.Write( "Object array: " );
      PrintValues( myObjArray );
   }


   public static void PrintValues( Object[] myArr )  {
      foreach ( Object i in myArr )  {
         Console.Write( "\t{0}", i );
      }
      Console.WriteLine();
   }

   public static void PrintValues( int[] myArr )  {
      foreach ( int i in myArr )  {
         Console.Write( "\t{0}", i );
      }
      Console.WriteLine();
   }
}
/* 
This code produces the following output.

Initially,
integer array:  1       2       3       4       5
Object array:   26      27      28      29      30

After copying the first two elements of the integer array to the Object array,
integer array:  1       2       3       4       5
Object array:   1       2       28      29      30

After copying the last two elements of the Object array to the integer array,
integer array:  1       2       3       29      30
Object array:   1       2       28      29      30
*/


public class SamplesArray
{
    public static void main(String[] args)
    {
        // Creates and initializes a new integer array and a new Object array.
        int myIntArray[] = new int[] { 1, 2, 3, 4, 5 };
        Object myObjArray[] = new Object[] { (Int32)26, (Int32)27, (Int32)28, 
            (Int32)29, (Int32)30};
        // Prints the initial values of both arrays.
        Console.WriteLine("Initially,");
        Console.Write("integer array:");
        PrintValues(myIntArray);
        Console.Write("Object array: ");
        PrintValues(myObjArray);
        // Copies the first two elements from the integer array to the 
        // Object array.
        System.Array.Copy(myIntArray, myObjArray, 2);
        // Prints the values of the modified arrays.
        Console.WriteLine("\nAfter copying the first two elements of the"
            + " integer array to the Object array,");
        Console.Write("integer array:");
        PrintValues(myIntArray);
        Console.Write("Object array: ");
        PrintValues(myObjArray);
        // Copies the last two elements from the Object array to the
        // integer array.
        System.Array.Copy(myObjArray, myObjArray.GetUpperBound(0) - 1, myIntArray, 
            myIntArray.GetUpperBound(0) - 1, 2);
        // Prints the values of the modified arrays.
        Console.WriteLine("\nAfter copying the last two elements of the Object"
            + " array to the integer array,");
        Console.Write("integer array:");
        PrintValues(myIntArray);
        Console.Write("Object array: ");
        PrintValues(myObjArray);
    } //main

    public static void PrintValues(Object myArr[])
    {
        Object i = null;
        for (int iCtr = 0; iCtr < myArr.get_Length(); iCtr++) {
            i = myArr[iCtr];
            Console.Write("\t{0}", i);
        }
        Console.WriteLine();
    } //PrintValues

    public static void PrintValues(int myArr[])
    { 
        int i = 0;
        for (int iCtr = 0; iCtr < myArr.get_Length(); iCtr++) {
            i = myArr[iCtr];
            Console.Write("\t{0}", (Int32)i);
        }
        Console.WriteLine();
    } //PrintValues
} //SamplesArray

/* 
 This code produces the following output.

 Initially,
 integer array:  1       2       3       4       5
 Object array:   26      27      28      29      30

 After copying the first two elements of the integer array to the Object array,
 integer array:  1       2       3       4       5
 Object array:   1       2       28      29      30

 After copying the last two elements of the Object array to the integer array,
 integer array:  1       2       3       29      30
 Object array:   1       2       28      29      30
 */


Nell'esempio di codice seguente viene creato e inizializzato un oggetto Array, e ne vengono visualizzati gli elementi e le proprietà.

public class SamplesArray2{

   public static void Main()  {

      // Creates and initializes a new three-dimensional Array of type Int32.
      Array myArr = Array.CreateInstance( typeof(Int32), 2, 3, 4 );
      for ( int i = myArr.GetLowerBound(0); i <= myArr.GetUpperBound(0); i++ )
         for ( int j = myArr.GetLowerBound(1); j <= myArr.GetUpperBound(1); j++ )
            for ( int k = myArr.GetLowerBound(2); k <= myArr.GetUpperBound(2); k++ )  {
               myArr.SetValue( (i*100)+(j*10)+k, i, j, k );
            }

      // Displays the properties of the Array.
      Console.WriteLine( "The Array has {0} dimension(s) and a total of {1} elements.", myArr.Rank, myArr.Length );
      Console.WriteLine( "\tLength\tLower\tUpper" );
      for ( int i = 0; i < myArr.Rank; i++ )  {
         Console.Write( "{0}:\t{1}", i, myArr.GetLength(i) );
         Console.WriteLine( "\t{0}\t{1}", myArr.GetLowerBound(i), myArr.GetUpperBound(i) );
      }

      // Displays the contents of the Array.
      Console.WriteLine( "The Array contains the following values:" );
      PrintValues( myArr );
   }


   public static void PrintValues( Array myArr )  {
      System.Collections.IEnumerator myEnumerator = myArr.GetEnumerator();
      int i = 0;
      int cols = myArr.GetLength( myArr.Rank - 1 );
      while ( myEnumerator.MoveNext() )  {
         if ( i < cols )  {
            i++;
         } else  {
            Console.WriteLine();
            i = 1;
         }
         Console.Write( "\t{0}", myEnumerator.Current );
      }
      Console.WriteLine();
   }
}
/* 
This code produces the following output.

The Array has 3 dimension(s) and a total of 24 elements.
    Length    Lower    Upper
0:    2    0    1
1:    3    0    2
2:    4    0    3
The Array contains the following values:
    0    1    2    3
    10    11    12    13
    20    21    22    23
    100    101    102    103
    110    111    112    113
    120    121    122    123
*/


public class SamplesArray2
{
    public static void main(String[] args)
    {
        // Creates and initializes a new three-dimensional Array of type Int32.
        Array myArr = Array.CreateInstance(Int32.class.ToType(), 2, 3, 4);
        for (int i = myArr.GetLowerBound(0); i <= myArr.GetUpperBound(0); i++) {
            for (int j = myArr.GetLowerBound(1); j <= myArr.GetUpperBound(1);
                j++) {
                for (int k = myArr.GetLowerBound(2); k <= myArr.
                    GetUpperBound(2); k++) {
                    myArr.SetValue((Int32)(i * 100 + j * 10 + k), i, j, k);
                }
            }
        }  // Displays the properties of the Array.
        Console.WriteLine("The Array has {0} dimension(s) and a total of"
            + " {1} elements.", System.Convert.ToString(myArr.get_Rank()), 
            System.Convert.ToString(myArr.get_Length()));
        Console.WriteLine("\tLength\tLower\tUpper");
        for (int i = 0; i < myArr.get_Rank(); i++) {
            Console.Write("{0}:\t{1}", System.Convert.ToString(i), 
                System.Convert.ToString(myArr.GetLength(i)));
            Console.WriteLine("\t{0}\t{1}", System.Convert.ToString(myArr.
                GetLowerBound(i)), System.Convert.ToString(myArr.
                GetUpperBound(i)));
        }
        // Displays the contents of the Array.
        Console.WriteLine("The Array contains the following values:");
        PrintValues(myArr);
    } //main

    public static void PrintValues(Array myArr)
    {
        System.Collections.IEnumerator myEnumerator = myArr.GetEnumerator();
        int i = 0;
        int cols = myArr.GetLength(myArr.get_Rank() - 1);
        while (myEnumerator.MoveNext()) {
            if (i < cols) {
                i++;
            }
            else {
                Console.WriteLine();
                i = 1;
            }
            Console.Write("\t{0}", myEnumerator.get_Current());
        }
        Console.WriteLine();
    } //PrintValues
} //SamplesArray2

/* 
 This code produces the following output.

 The Array has 3 dimension(s) and a total of 24 elements.
     Length    Lower    Upper
 0:    2    0    1
 1:    3    0    2
 2:    4    0    3
 The Array contains the following values:
     0    1    2    3
     10    11    12    13
     20    21    22    23
     100    101    102    103
     110    111    112    113
     120    121    122    123
 */


I membri statici pubblici (Shared in Visual Basic) di questo tipo sono thread-safe. Qualsiasi membro di istanza non ha garanzia di essere thread-safe.

Questa implementazione non fornisce un wrapper sincronizzato (thread-safe) per un oggetto Array; tuttavia, le classi .NET Framework basate su Array forniscono la propria versione sincronizzata dell'insieme utilizzando la proprietà SyncRoot.

L'enumerazione di un insieme non è di per sé una procedura thread-safe. Anche se un insieme è sincronizzato, è possibile che venga modificato da altri thread, con conseguente generazione di un'eccezione da parte dell'enumeratore. Per garantire che un insieme sia thread-safe durante l'enumerazione, è possibile bloccarlo nel corso dell'operazione oppure rilevare le eccezioni generate dalle modifiche apportate da altri thread.

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition , Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile per Smartphone, Windows Mobile per Pocket PC, Xbox 360

.NET Framework e .NET Compact Framework non supportano tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

.NET Framework

Supportato in: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Supportato in: 3.5, 2.0, 1.0

XNA Framework

Supportato in: 2.0, 1.0

Aggiunte alla community

AGGIUNGI
Microsoft sta conducendo un sondaggio in linea per comprendere l'opinione degli utenti in merito al sito Web di MSDN. Se si sceglie di partecipare, quando si lascia il sito Web di MSDN verrà visualizzato il sondaggio in linea.

Si desidera partecipare?
Mostra:
© 2014 Microsoft