Array.CreateInstance Metodo
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Inizializza una nuova istanza della classe Array.
Overload
| CreateInstance(Type, Int32) |
Crea un oggetto Array unidimensionale dell'oggetto Type specificato e della lunghezza, con indice in base zero. |
| CreateInstance(Type, Int32[]) |
Crea un oggetto Array multidimensionale dell'oggetto Type specificato e delle lunghezze della dimensione, con indicizzazione in base zero. Le lunghezze vengono specificate in una matrice di interi a 32 bit. |
| CreateInstance(Type, Int64[]) |
Crea un oggetto Array multidimensionale dell'oggetto Type specificato e delle lunghezze della dimensione, con indicizzazione in base zero. Le lunghezze delle dimensioni vengono specificate in una matrice di interi a 64 bit. |
| CreateInstance(Type, Int32, Int32) |
Crea un oggetto Array bidimensionale dell'oggetto Type specificato e delle lunghezze delle dimensioni specificate, con indice in base zero. |
| CreateInstance(Type, Int32[], Int32[]) |
Crea una matrice Array multidimensionale con il valore Type e lunghezze della dimensione specificati, con i limiti inferiori specificati. |
| CreateInstance(Type, Int32, Int32, Int32) |
Crea un oggetto Array tridimensionale dell'oggetto Type specificato e le lunghezze della dimensione, con indice in base zero. |
CreateInstance(Type, Int32)
- Source:
- Array.cs
- Source:
- Array.cs
- Source:
- Array.cs
public:
static Array ^ CreateInstance(Type ^ elementType, int length);public static Array CreateInstance (Type elementType, int length);static member CreateInstance : Type * int -> ArrayPublic Shared Function CreateInstance (elementType As Type, length As Integer) As ArrayParametri
Restituisce
Nuovo oggetto Array unidimensionale dell'oggetto Type specificato con la lunghezza indicata e con indice in base zero.
Eccezioni
elementType è null.
elementType non è un oggetto Type valido.
elementType non è supportato. Ad esempio, Void non è supportato.
-oppure-
elementType è un tipo generico aperto.
length è minore di zero.
Esempio
Nell'esempio di codice seguente viene illustrato come creare e inizializzare un oggetto unidimensionale Array.
using namespace System;
void PrintValues( Array^ myArr );
void main()
{
// Creates and initializes a one-dimensional Array instance of type Int32.
Array^ my1DArray = Array::CreateInstance( Int32::typeid, 5 );
for ( int i = my1DArray->GetLowerBound( 0 ); i <= my1DArray->GetUpperBound( 0 ); i++ )
my1DArray->SetValue( i + 1, i );
// Displays the values of the Array.
Console::WriteLine( "The one-dimensional Array instance contains the following values:" );
PrintValues( my1DArray );
}
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 one-dimensional Array instance contains the following values:
1 2 3 4 5
*/
open System
let printValues (myArr: Array) =
let mutable i = 0
let cols = myArr.GetLength(myArr.Rank - 1)
for item in myArr do
if i < cols then
i <- i + 1
else
printfn ""
i <- 1
printf $"\t{item}"
printfn ""
// Creates and initializes a one-dimensional Array of type int.
let my1DArray = Array.CreateInstance(typeof<int>, 5)
// let my1DArrayy = Array.zeroCreate<int> 5
for i = my1DArray.GetLowerBound 0 to my1DArray.GetUpperBound 0 do
my1DArray.SetValue(i+1, i)
// Displays the values of the Array.
printfn "The one-dimensional Array contains the following values:"
printValues my1DArray
// This code produces the following output.
// The one-dimensional Array contains the following values:
// 1 2 3 4 5
using System;
public class SamplesArray {
public static void Main() {
// Creates and initializes a one-dimensional Array of type int.
Array my1DArray=Array.CreateInstance( typeof(int), 5 );
for ( int i = my1DArray.GetLowerBound(0); i <= my1DArray.GetUpperBound(0); i++ )
my1DArray.SetValue( i+1, i );
// Displays the values of the Array.
Console.WriteLine( "The one-dimensional Array contains the following values:" );
PrintValues( my1DArray );
}
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 one-dimensional Array contains the following values:
1 2 3 4 5
*/
Public Class SamplesArray
Public Shared Sub Main()
' Creates and initializes a one-dimensional Array of type Int32.
Dim my1DArray As Array = Array.CreateInstance(GetType(Int32), 5)
Dim i As Integer
For i = my1DArray.GetLowerBound(0) To my1DArray.GetUpperBound(0)
my1DArray.SetValue(i + 1, i)
Next i
' Displays the values of the Array.
Console.WriteLine("The one-dimensional Array contains the " _
+ "following values:")
PrintValues(my1DArray)
End Sub
Public Shared Sub PrintValues(myArr As Array)
Dim myEnumerator As System.Collections.IEnumerator = _
myArr.GetEnumerator()
Dim i As Integer = 0
Dim cols As Integer = myArr.GetLength((myArr.Rank - 1))
While myEnumerator.MoveNext()
If i < cols Then
i += 1
Else
Console.WriteLine()
i = 1
End If
Console.Write(ControlChars.Tab + "{0}", myEnumerator.Current)
End While
Console.WriteLine()
End Sub
End Class
' This code produces the following output.
'
' The one-dimensional Array contains the following values:
' 1 2 3 4 5
Commenti
A differenza della maggior parte delle classi, Array fornisce il CreateInstance metodo , anziché i costruttori pubblici, per consentire l'accesso con associazione tardiva.
Gli elementi di tipo riferimento vengono inizializzati in null. Gli elementi di tipo valore vengono inizializzati su zero.
Questo metodo è un'operazione O(n), dove n è length.
In F# la funzione Array.zeroCreate viene in genere usata.
Si applica a
CreateInstance(Type, Int32[])
- Source:
- Array.cs
- Source:
- Array.cs
- Source:
- Array.cs
public:
static Array ^ CreateInstance(Type ^ elementType, ... cli::array <int> ^ lengths);public static Array CreateInstance (Type elementType, params int[] lengths);static member CreateInstance : Type * int[] -> ArrayPublic Shared Function CreateInstance (elementType As Type, ParamArray lengths As Integer()) As ArrayParametri
- lengths
- Int32[]
Matrice di interi a 32 bit che rappresentano le grandezze di ciascuna dimensione dell'oggetto Array da creare.
Restituisce
Nuovo oggetto Array multidimensionale dell'oggetto Type specificato, con la lunghezza specificata per ogni dimensione, usando l'indicizzazione in base zero.
Eccezioni
elementType non è un oggetto Type valido.
-oppure-
La matrice di lengths contiene meno di un elemento.
elementType non è supportato. Ad esempio, Void non è supportato.
-oppure-
elementType è un tipo generico aperto.
Qualsiasi valore in lengths è minore di zero.
Esempio
Nell'esempio di codice seguente viene illustrato come creare e inizializzare un oggetto multidimensionale Array.
using namespace System;
void PrintValues( Array^ myArr );
void main()
{
// Creates and initializes a multidimensional Array instance of type String.
array<int>^myLengthsArray = {2,3,4,5};
Array^ my4DArray = Array::CreateInstance( String::typeid, myLengthsArray );
for ( int i = my4DArray->GetLowerBound( 0 ); i <= my4DArray->GetUpperBound( 0 ); i++ )
for ( int j = my4DArray->GetLowerBound( 1 ); j <= my4DArray->GetUpperBound( 1 ); j++ )
for ( int k = my4DArray->GetLowerBound( 2 ); k <= my4DArray->GetUpperBound( 2 ); k++ )
for ( int l = my4DArray->GetLowerBound( 3 ); l <= my4DArray->GetUpperBound( 3 ); l++ )
{
array<int>^myIndicesArray = {i,j,k,l};
my4DArray->SetValue( String::Concat( Convert::ToString( i ), j, k, l ), myIndicesArray );
}
// Displays the values of the Array.
Console::WriteLine( "The four-dimensional Array instance contains the following values:" );
PrintValues( my4DArray );
}
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 four-dimensional Array instance contains the following values:
0000 0001 0002 0003 0004
0010 0011 0012 0013 0014
0020 0021 0022 0023 0024
0030 0031 0032 0033 0034
0100 0101 0102 0103 0104
0110 0111 0112 0113 0114
0120 0121 0122 0123 0124
0130 0131 0132 0133 0134
0200 0201 0202 0203 0204
0210 0211 0212 0213 0214
0220 0221 0222 0223 0224
0230 0231 0232 0233 0234
1000 1001 1002 1003 1004
1010 1011 1012 1013 1014
1020 1021 1022 1023 1024
1030 1031 1032 1033 1034
1100 1101 1102 1103 1104
1110 1111 1112 1113 1114
1120 1121 1122 1123 1124
1130 1131 1132 1133 1134
1200 1201 1202 1203 1204
1210 1211 1212 1213 1214
1220 1221 1222 1223 1224
1230 1231 1232 1233 1234
*/
open System
let printValues (myArray: Array) =
let mutable i = 0
let cols = myArray.GetLength(myArray.Rank - 1)
for item in myArray do
if i < cols then
i <- i + 1
else
printfn ""
i <- 1;
printf $"\t{item}"
printfn ""
// Creates and initializes a multidimensional Array of type string.
let my4DArray = Array.CreateInstance( typeof<string>, [| 2..5 |] )
for i = my4DArray.GetLowerBound 0 to my4DArray.GetUpperBound 0 do
for j = my4DArray.GetLowerBound 1 to my4DArray.GetUpperBound 1 do
for k = my4DArray.GetLowerBound 2 to my4DArray.GetUpperBound 2 do
for l = my4DArray.GetLowerBound 3 to my4DArray.GetUpperBound 3 do
let myIndicesArray = [| i; j; k; l |]
my4DArray.SetValue($"{i}{j}{k}{l}", myIndicesArray)
// Displays the values of the Array.
printfn "The four-dimensional Array contains the following values:"
printValues my4DArray
// This code produces the following output.
// The four-dimensional Array contains the following values:
// 0000 0001 0002 0003 0004
// 0010 0011 0012 0013 0014
// 0020 0021 0022 0023 0024
// 0030 0031 0032 0033 0034
// 0100 0101 0102 0103 0104
// 0110 0111 0112 0113 0114
// 0120 0121 0122 0123 0124
// 0130 0131 0132 0133 0134
// 0200 0201 0202 0203 0204
// 0210 0211 0212 0213 0214
// 0220 0221 0222 0223 0224
// 0230 0231 0232 0233 0234
// 1000 1001 1002 1003 1004
// 1010 1011 1012 1013 1014
// 1020 1021 1022 1023 1024
// 1030 1031 1032 1033 1034
// 1100 1101 1102 1103 1104
// 1110 1111 1112 1113 1114
// 1120 1121 1122 1123 1124
// 1130 1131 1132 1133 1134
// 1200 1201 1202 1203 1204
// 1210 1211 1212 1213 1214
// 1220 1221 1222 1223 1224
// 1230 1231 1232 1233 1234
using System;
public class SamplesArray3 {
public static void Main() {
// Creates and initializes a multidimensional Array of type string.
int[] myLengthsArray = new int[4] { 2, 3, 4, 5 };
Array my4DArray=Array.CreateInstance( typeof(string), myLengthsArray );
for ( int i = my4DArray.GetLowerBound(0); i <= my4DArray.GetUpperBound(0); i++ )
for ( int j = my4DArray.GetLowerBound(1); j <= my4DArray.GetUpperBound(1); j++ )
for ( int k = my4DArray.GetLowerBound(2); k <= my4DArray.GetUpperBound(2); k++ )
for ( int l = my4DArray.GetLowerBound(3); l <= my4DArray.GetUpperBound(3); l++ ) {
int[] myIndicesArray = new int[4] { i, j, k, l };
my4DArray.SetValue( Convert.ToString(i) + j + k + l, myIndicesArray );
}
// Displays the values of the Array.
Console.WriteLine( "The four-dimensional Array contains the following values:" );
PrintValues( my4DArray );
}
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 four-dimensional Array contains the following values:
0000 0001 0002 0003 0004
0010 0011 0012 0013 0014
0020 0021 0022 0023 0024
0030 0031 0032 0033 0034
0100 0101 0102 0103 0104
0110 0111 0112 0113 0114
0120 0121 0122 0123 0124
0130 0131 0132 0133 0134
0200 0201 0202 0203 0204
0210 0211 0212 0213 0214
0220 0221 0222 0223 0224
0230 0231 0232 0233 0234
1000 1001 1002 1003 1004
1010 1011 1012 1013 1014
1020 1021 1022 1023 1024
1030 1031 1032 1033 1034
1100 1101 1102 1103 1104
1110 1111 1112 1113 1114
1120 1121 1122 1123 1124
1130 1131 1132 1133 1134
1200 1201 1202 1203 1204
1210 1211 1212 1213 1214
1220 1221 1222 1223 1224
1230 1231 1232 1233 1234
*/
Public Class SamplesArray
Public Shared Sub Main()
' Creates and initializes a multidimensional Array of type String.
Dim myLengthsArray() As Integer = {2, 3, 4, 5}
Dim my4DArray As Array = Array.CreateInstance(GetType(String), myLengthsArray)
Dim i, j, k, l As Integer
Dim myIndicesArray() As Integer
For i = my4DArray.GetLowerBound(0) To my4DArray.GetUpperBound(0)
For j = my4DArray.GetLowerBound(1) To my4DArray.GetUpperBound(1)
For k = my4DArray.GetLowerBound(2) To my4DArray.GetUpperBound(2)
For l = my4DArray.GetLowerBound(3) To my4DArray.GetUpperBound(3)
myIndicesArray = New Integer() {i, j, k, l}
my4DArray.SetValue(Convert.ToString(i) + j.ToString() _
+ k.ToString() + l.ToString(), myIndicesArray)
Next l
Next k
Next j
Next i
' Displays the values of the Array.
Console.WriteLine("The four-dimensional Array contains the following values:")
PrintValues(my4DArray)
End Sub
Public Shared Sub PrintValues(myArr As Array)
Dim myEnumerator As System.Collections.IEnumerator = myArr.GetEnumerator()
Dim i As Integer = 0
Dim cols As Integer = myArr.GetLength(myArr.Rank - 1)
While myEnumerator.MoveNext()
If i < cols Then
i += 1
Else
Console.WriteLine()
i = 1
End If
Console.Write(ControlChars.Tab + "{0}", myEnumerator.Current)
End While
Console.WriteLine()
End Sub
End Class
' This code produces the following output.
'
' The four-dimensional Array contains the following values:
' 0000 0001 0002 0003 0004
' 0010 0011 0012 0013 0014
' 0020 0021 0022 0023 0024
' 0030 0031 0032 0033 0034
' 0100 0101 0102 0103 0104
' 0110 0111 0112 0113 0114
' 0120 0121 0122 0123 0124
' 0130 0131 0132 0133 0134
' 0200 0201 0202 0203 0204
' 0210 0211 0212 0213 0214
' 0220 0221 0222 0223 0224
' 0230 0231 0232 0233 0234
' 1000 1001 1002 1003 1004
' 1010 1011 1012 1013 1014
' 1020 1021 1022 1023 1024
' 1030 1031 1032 1033 1034
' 1100 1101 1102 1103 1104
' 1110 1111 1112 1113 1114
' 1120 1121 1122 1123 1124
' 1130 1131 1132 1133 1134
' 1200 1201 1202 1203 1204
' 1210 1211 1212 1213 1214
' 1220 1221 1222 1223 1224
' 1230 1231 1232 1233 1234
Commenti
A differenza della maggior parte delle classi, Array fornisce il CreateInstance metodo , anziché i costruttori pubblici, per consentire l'accesso con associazione tardiva.
Il numero di elementi nella lengths matrice deve essere uguale al numero di dimensioni nel nuovo Arrayoggetto . Ogni elemento della lengths matrice deve specificare la lunghezza della dimensione corrispondente nel nuovo Arrayoggetto .
Gli elementi di tipo riferimento vengono inizializzati in null. Gli elementi di tipo valore vengono inizializzati su zero.
Questo metodo è un'operazione O(n), dove n è il prodotto di tutti i valori in lengths.
Si applica a
CreateInstance(Type, Int64[])
- Source:
- Array.cs
- Source:
- Array.cs
- Source:
- Array.cs
public:
static Array ^ CreateInstance(Type ^ elementType, ... cli::array <long> ^ lengths);public static Array CreateInstance (Type elementType, params long[] lengths);static member CreateInstance : Type * int64[] -> ArrayPublic Shared Function CreateInstance (elementType As Type, ParamArray lengths As Long()) As ArrayParametri
- lengths
- Int64[]
Matrice di interi a 64 bit che rappresentano le grandezze di ciascuna dimensione dell'oggetto Array da creare. Ogni numero intero nella matrice deve essere compreso tra zero e Int32.MaxValue, inclusi.
Restituisce
Nuovo oggetto Array multidimensionale dell'oggetto Type specificato, con la lunghezza specificata per ogni dimensione, usando l'indicizzazione in base zero.
Eccezioni
elementType non è un oggetto Type valido.
-oppure-
La matrice di lengths contiene meno di un elemento.
elementType non è supportato. Ad esempio, Void non è supportato.
-oppure-
elementType è un tipo generico aperto.
Qualsiasi valore in lengths è minore di zero o maggiore di Int32.MaxValue.
Esempio
Nell'esempio di codice seguente viene illustrato come creare e inizializzare un oggetto multidimensionale Array.
using namespace System;
void PrintValues( Array^ myArr );
void main()
{
// Creates and initializes a multidimensional Array instance of type String.
array<int>^myLengthsArray = {2,3,4,5};
Array^ my4DArray = Array::CreateInstance( String::typeid, myLengthsArray );
for ( int i = my4DArray->GetLowerBound( 0 ); i <= my4DArray->GetUpperBound( 0 ); i++ )
for ( int j = my4DArray->GetLowerBound( 1 ); j <= my4DArray->GetUpperBound( 1 ); j++ )
for ( int k = my4DArray->GetLowerBound( 2 ); k <= my4DArray->GetUpperBound( 2 ); k++ )
for ( int l = my4DArray->GetLowerBound( 3 ); l <= my4DArray->GetUpperBound( 3 ); l++ )
{
array<int>^myIndicesArray = {i,j,k,l};
my4DArray->SetValue( String::Concat( Convert::ToString( i ), j, k, l ), myIndicesArray );
}
// Displays the values of the Array.
Console::WriteLine( "The four-dimensional Array instance contains the following values:" );
PrintValues( my4DArray );
}
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 four-dimensional Array instance contains the following values:
0000 0001 0002 0003 0004
0010 0011 0012 0013 0014
0020 0021 0022 0023 0024
0030 0031 0032 0033 0034
0100 0101 0102 0103 0104
0110 0111 0112 0113 0114
0120 0121 0122 0123 0124
0130 0131 0132 0133 0134
0200 0201 0202 0203 0204
0210 0211 0212 0213 0214
0220 0221 0222 0223 0224
0230 0231 0232 0233 0234
1000 1001 1002 1003 1004
1010 1011 1012 1013 1014
1020 1021 1022 1023 1024
1030 1031 1032 1033 1034
1100 1101 1102 1103 1104
1110 1111 1112 1113 1114
1120 1121 1122 1123 1124
1130 1131 1132 1133 1134
1200 1201 1202 1203 1204
1210 1211 1212 1213 1214
1220 1221 1222 1223 1224
1230 1231 1232 1233 1234
*/
open System
let printValues (myArray: Array) =
let mutable i = 0
let cols = myArray.GetLength(myArray.Rank - 1)
for item in myArray do
if i < cols then
i <- i + 1
else
printfn ""
i <- 1;
printf $"\t{item}"
printfn ""
// Creates and initializes a multidimensional Array of type string.
let my4DArray = Array.CreateInstance( typeof<string>, [| 2..5 |] )
for i = my4DArray.GetLowerBound 0 to my4DArray.GetUpperBound 0 do
for j = my4DArray.GetLowerBound 1 to my4DArray.GetUpperBound 1 do
for k = my4DArray.GetLowerBound 2 to my4DArray.GetUpperBound 2 do
for l = my4DArray.GetLowerBound 3 to my4DArray.GetUpperBound 3 do
let myIndicesArray = [| i; j; k; l |]
my4DArray.SetValue($"{i}{j}{k}{l}", myIndicesArray)
// Displays the values of the Array.
printfn "The four-dimensional Array contains the following values:"
printValues my4DArray
// This code produces the following output.
// The four-dimensional Array contains the following values:
// 0000 0001 0002 0003 0004
// 0010 0011 0012 0013 0014
// 0020 0021 0022 0023 0024
// 0030 0031 0032 0033 0034
// 0100 0101 0102 0103 0104
// 0110 0111 0112 0113 0114
// 0120 0121 0122 0123 0124
// 0130 0131 0132 0133 0134
// 0200 0201 0202 0203 0204
// 0210 0211 0212 0213 0214
// 0220 0221 0222 0223 0224
// 0230 0231 0232 0233 0234
// 1000 1001 1002 1003 1004
// 1010 1011 1012 1013 1014
// 1020 1021 1022 1023 1024
// 1030 1031 1032 1033 1034
// 1100 1101 1102 1103 1104
// 1110 1111 1112 1113 1114
// 1120 1121 1122 1123 1124
// 1130 1131 1132 1133 1134
// 1200 1201 1202 1203 1204
// 1210 1211 1212 1213 1214
// 1220 1221 1222 1223 1224
// 1230 1231 1232 1233 1234
using System;
public class SamplesArray3 {
public static void Main() {
// Creates and initializes a multidimensional Array of type string.
int[] myLengthsArray = new int[4] { 2, 3, 4, 5 };
Array my4DArray=Array.CreateInstance( typeof(string), myLengthsArray );
for ( int i = my4DArray.GetLowerBound(0); i <= my4DArray.GetUpperBound(0); i++ )
for ( int j = my4DArray.GetLowerBound(1); j <= my4DArray.GetUpperBound(1); j++ )
for ( int k = my4DArray.GetLowerBound(2); k <= my4DArray.GetUpperBound(2); k++ )
for ( int l = my4DArray.GetLowerBound(3); l <= my4DArray.GetUpperBound(3); l++ ) {
int[] myIndicesArray = new int[4] { i, j, k, l };
my4DArray.SetValue( Convert.ToString(i) + j + k + l, myIndicesArray );
}
// Displays the values of the Array.
Console.WriteLine( "The four-dimensional Array contains the following values:" );
PrintValues( my4DArray );
}
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 four-dimensional Array contains the following values:
0000 0001 0002 0003 0004
0010 0011 0012 0013 0014
0020 0021 0022 0023 0024
0030 0031 0032 0033 0034
0100 0101 0102 0103 0104
0110 0111 0112 0113 0114
0120 0121 0122 0123 0124
0130 0131 0132 0133 0134
0200 0201 0202 0203 0204
0210 0211 0212 0213 0214
0220 0221 0222 0223 0224
0230 0231 0232 0233 0234
1000 1001 1002 1003 1004
1010 1011 1012 1013 1014
1020 1021 1022 1023 1024
1030 1031 1032 1033 1034
1100 1101 1102 1103 1104
1110 1111 1112 1113 1114
1120 1121 1122 1123 1124
1130 1131 1132 1133 1134
1200 1201 1202 1203 1204
1210 1211 1212 1213 1214
1220 1221 1222 1223 1224
1230 1231 1232 1233 1234
*/
Public Class SamplesArray
Public Shared Sub Main()
' Creates and initializes a multidimensional Array of type String.
Dim myLengthsArray() As Integer = {2, 3, 4, 5}
Dim my4DArray As Array = Array.CreateInstance(GetType(String), myLengthsArray)
Dim i, j, k, l As Integer
Dim myIndicesArray() As Integer
For i = my4DArray.GetLowerBound(0) To my4DArray.GetUpperBound(0)
For j = my4DArray.GetLowerBound(1) To my4DArray.GetUpperBound(1)
For k = my4DArray.GetLowerBound(2) To my4DArray.GetUpperBound(2)
For l = my4DArray.GetLowerBound(3) To my4DArray.GetUpperBound(3)
myIndicesArray = New Integer() {i, j, k, l}
my4DArray.SetValue(Convert.ToString(i) + j.ToString() _
+ k.ToString() + l.ToString(), myIndicesArray)
Next l
Next k
Next j
Next i
' Displays the values of the Array.
Console.WriteLine("The four-dimensional Array contains the following values:")
PrintValues(my4DArray)
End Sub
Public Shared Sub PrintValues(myArr As Array)
Dim myEnumerator As System.Collections.IEnumerator = myArr.GetEnumerator()
Dim i As Integer = 0
Dim cols As Integer = myArr.GetLength(myArr.Rank - 1)
While myEnumerator.MoveNext()
If i < cols Then
i += 1
Else
Console.WriteLine()
i = 1
End If
Console.Write(ControlChars.Tab + "{0}", myEnumerator.Current)
End While
Console.WriteLine()
End Sub
End Class
' This code produces the following output.
'
' The four-dimensional Array contains the following values:
' 0000 0001 0002 0003 0004
' 0010 0011 0012 0013 0014
' 0020 0021 0022 0023 0024
' 0030 0031 0032 0033 0034
' 0100 0101 0102 0103 0104
' 0110 0111 0112 0113 0114
' 0120 0121 0122 0123 0124
' 0130 0131 0132 0133 0134
' 0200 0201 0202 0203 0204
' 0210 0211 0212 0213 0214
' 0220 0221 0222 0223 0224
' 0230 0231 0232 0233 0234
' 1000 1001 1002 1003 1004
' 1010 1011 1012 1013 1014
' 1020 1021 1022 1023 1024
' 1030 1031 1032 1033 1034
' 1100 1101 1102 1103 1104
' 1110 1111 1112 1113 1114
' 1120 1121 1122 1123 1124
' 1130 1131 1132 1133 1134
' 1200 1201 1202 1203 1204
' 1210 1211 1212 1213 1214
' 1220 1221 1222 1223 1224
' 1230 1231 1232 1233 1234
Commenti
A differenza della maggior parte delle classi, Array fornisce il CreateInstance metodo , anziché i costruttori pubblici, per consentire l'accesso con associazione tardiva.
Il numero di elementi nella lengths matrice deve essere uguale al numero di dimensioni nel nuovo Arrayoggetto . Ogni elemento della lengths matrice deve specificare la lunghezza della dimensione corrispondente nel nuovo Arrayoggetto .
Gli elementi di tipo riferimento vengono inizializzati in null. Gli elementi di tipo valore vengono inizializzati su zero.
Questo metodo è un'operazione O(n), dove n è il prodotto di tutti i valori in lengths.
Si applica a
CreateInstance(Type, Int32, Int32)
- Source:
- Array.cs
- Source:
- Array.cs
- Source:
- Array.cs
public:
static Array ^ CreateInstance(Type ^ elementType, int length1, int length2);public static Array CreateInstance (Type elementType, int length1, int length2);static member CreateInstance : Type * int * int -> ArrayPublic Shared Function CreateInstance (elementType As Type, length1 As Integer, length2 As Integer) As ArrayParametri
Restituisce
Nuovo oggetto Array bidimensionale dell'oggetto Type specificato con la lunghezza specificata per ciascuna dimensione, con indice in base zero.
Eccezioni
elementType è null.
elementType non è un oggetto Type valido.
elementType non è supportato. Ad esempio, Void non è supportato.
-oppure-
elementType è un tipo generico aperto.
Esempio
Nell'esempio di codice seguente viene illustrato come creare e inizializzare un oggetto bidimensionale Array.
using namespace System;
void PrintValues( Array^ myArr );
void main()
{
// Creates and initializes a two-dimensional Array instance of type String.
Array^ my2DArray = Array::CreateInstance( String::typeid, 2, 3 );
for ( int i = my2DArray->GetLowerBound( 0 ); i <= my2DArray->GetUpperBound( 0 ); i++ )
for ( int j = my2DArray->GetLowerBound( 1 ); j <= my2DArray->GetUpperBound( 1 ); j++ )
my2DArray->SetValue( String::Concat( "abc", i, j ), i, j );
// Displays the values of the Array.
Console::WriteLine( "The two-dimensional Array instance contains the following values:" );
PrintValues( my2DArray );
}
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 two-dimensional Array instance contains the following values:
abc00 abc01 abc02
abc10 abc11 abc12
*/
open System
let printValues (myArray: Array) =
let mutable i = 0
let cols = myArray.GetLength(myArray.Rank - 1)
for item in myArray do
if i < cols then
i <- i + 1
else
printfn ""
i <- 1;
printf $"\t{item}"
printfn ""
// Creates and initializes a two-dimensional Array of type string.
let my2DArray = Array.CreateInstance(typeof<string>, 2, 3)
// let my2DArray2 = Array2D.zeroCreate<string> 2 3
for i = my2DArray.GetLowerBound 0 to my2DArray.GetUpperBound 0 do
for j = my2DArray.GetLowerBound 1 to my2DArray.GetUpperBound 1 do
my2DArray.SetValue( $"abc{i}{j}", i, j )
// Displays the values of the Array.
printfn "The two-dimensional Array contains the following values:"
printValues my2DArray
// This code produces the following output.
// The two-dimensional Array contains the following values:
// abc00 abc01 abc02
// abc10 abc11 abc12
using System;
public class SamplesArray1 {
public static void Main() {
// Creates and initializes a two-dimensional Array of type string.
Array my2DArray=Array.CreateInstance( typeof(string), 2, 3 );
for ( int i = my2DArray.GetLowerBound(0); i <= my2DArray.GetUpperBound(0); i++ )
for ( int j = my2DArray.GetLowerBound(1); j <= my2DArray.GetUpperBound(1); j++ )
my2DArray.SetValue( "abc" + i + j, i, j );
// Displays the values of the Array.
Console.WriteLine( "The two-dimensional Array contains the following values:" );
PrintValues( my2DArray );
}
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 two-dimensional Array contains the following values:
abc00 abc01 abc02
abc10 abc11 abc12
*/
Public Class SamplesArray
Public Shared Sub Main()
' Creates and initializes a two-dimensional Array of type String.
Dim my2DArray As Array = Array.CreateInstance(GetType(String), 2, 3)
Dim i, j As Integer
For i = my2DArray.GetLowerBound(0) To my2DArray.GetUpperBound(0)
For j = my2DArray.GetLowerBound(1) To my2DArray.GetUpperBound(1)
my2DArray.SetValue("abc" + i.ToString() + j.ToString(), i, j)
Next j
Next i
' Displays the values of the Array.
Console.WriteLine("The two-dimensional Array contains the " _
+ "following values:")
PrintValues(my2DArray)
End Sub
Public Shared Sub PrintValues(myArr As Array)
Dim myEnumerator As System.Collections.IEnumerator = _
myArr.GetEnumerator()
Dim i As Integer = 0
Dim cols As Integer = myArr.GetLength(myArr.Rank - 1)
While myEnumerator.MoveNext()
If i < cols Then
i += 1
Else
Console.WriteLine()
i = 1
End If
Console.Write(ControlChars.Tab + "{0}", myEnumerator.Current)
End While
Console.WriteLine()
End Sub
End Class
' This code produces the following output.
'
' The two-dimensional Array contains the following values:
' abc00 abc01 abc02
' abc10 abc11 abc12
Commenti
A differenza della maggior parte delle classi, Array fornisce il CreateInstance metodo , anziché i costruttori pubblici, per consentire l'accesso con associazione tardiva.
Gli elementi di tipo riferimento vengono inizializzati in null. Gli elementi di tipo valore vengono inizializzati su zero.
Questo metodo è un'operazione O(n), dove n è il prodotto di length1 e length2.
In F# è invece possibile usare la funzione Array2D.zeroCreate .
Si applica a
CreateInstance(Type, Int32[], Int32[])
- Source:
- Array.cs
- Source:
- Array.cs
- Source:
- Array.cs
public:
static Array ^ CreateInstance(Type ^ elementType, cli::array <int> ^ lengths, cli::array <int> ^ lowerBounds);public static Array CreateInstance (Type elementType, int[] lengths, int[] lowerBounds);static member CreateInstance : Type * int[] * int[] -> ArrayPublic Shared Function CreateInstance (elementType As Type, lengths As Integer(), lowerBounds As Integer()) As ArrayParametri
- lengths
- Int32[]
Matrice unidimensionale che contiene la grandezza di ciascuna dimensione dell'oggetto Array da creare.
- lowerBounds
- Int32[]
Matrice unidimensionale che contiene il limite inferiore (indice iniziale) di ciascuna dimensione dell'oggetto Array da creare.
Restituisce
Nuovo oggetto Array multidimensionale con il valore Type specificato, con la lunghezza e il limite inferiore specificati per ogni dimensione.
Eccezioni
elementType non è un oggetto Type valido.
-oppure-
La matrice di lengths contiene meno di un elemento.
-oppure-
Le matrici lengths e lowerBounds non contengono lo stesso numero di elementi.
elementType non è supportato. Ad esempio, Void non è supportato.
-oppure-
elementType è un tipo generico aperto.
Qualsiasi valore in lengths è minore di zero.
-oppure-
Qualsiasi valore in lowerBounds è molto grande, in modo che la somma del limite inferiore di una dimensione sia maggiore di Int32.MaxValue.
Esempio
Nell'esempio di codice seguente viene illustrato come creare e inizializzare un oggetto multidimensionale Array con limiti inferiori specificati.
using namespace System;
void PrintValues( Array^ myArr );
void main()
{
// Creates and initializes a multidimensional Array instance of type String.
array<int>^myLengthsArray = {3,5};
array<int>^myBoundsArray = {2,3};
Array^ myArray = Array::CreateInstance( String::typeid, myLengthsArray, myBoundsArray );
for ( int i = myArray->GetLowerBound( 0 ); i <= myArray->GetUpperBound( 0 ); i++ )
for ( int j = myArray->GetLowerBound( 1 ); j <= myArray->GetUpperBound( 1 ); j++ )
{
array<int>^myIndicesArray = {i,j};
myArray->SetValue( String::Concat( Convert::ToString( i ), j ), myIndicesArray );
}
// Displays the lower bounds and the upper bounds of each dimension.
Console::WriteLine( "Bounds:\tLower\tUpper" );
for ( int i = 0; i < myArray->Rank; i++ )
Console::WriteLine( "{0}:\t{1}\t{2}", i, myArray->GetLowerBound( i ), myArray->GetUpperBound( i ) );
// Displays the values of the Array.
Console::WriteLine( "The Array instance contains the following values:" );
PrintValues( myArray );
}
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.
Bounds: Lower Upper
0: 2 4
1: 3 7
The Array instance contains the following values:
23 24 25 26 27
33 34 35 36 37
43 44 45 46 47
*/
open System
let printValues (myArray: Array) =
let mutable i = 0
let cols = myArray.GetLength(myArray.Rank - 1)
for item in myArray do
if i < cols then
i <- i + 1
else
printfn ""
i <- 1;
printf $"\t{item}"
printfn ""
// Creates and initializes a multidimensional Array of type string.
let myLengthsArray = [| 3; 5 |]
let myBoundsArray = [| 2; 3 |]
let myArray = Array.CreateInstance(typeof<string>, myLengthsArray, myBoundsArray)
for i = myArray.GetLowerBound 0 to myArray.GetUpperBound 0 do
for j = myArray.GetLowerBound 1 to myArray.GetUpperBound 1 do
let myIndicesArray = [| i; j |]
myArray.SetValue($"{i}{j}", myIndicesArray)
// Displays the lower bounds and the upper bounds of each dimension.
printfn "Bounds:\tLower\tUpper"
for i = 0 to myArray.Rank - 1 do
printfn $"{i}:\t{myArray.GetLowerBound i}\t{myArray.GetUpperBound i}"
// Displays the values of the Array.
printfn "The Array contains the following values:"
printValues myArray
// This code produces the following output.
// Bounds: Lower Upper
// 0: 2 4
// 1: 3 7
// The Array contains the following values:
// 23 24 25 26 27
// 33 34 35 36 37
// 43 44 45 46 47
using System;
public class SamplesArray4 {
public static void Main() {
// Creates and initializes a multidimensional Array of type string.
int[] myLengthsArray = new int[2] { 3, 5 };
int[] myBoundsArray = new int[2] { 2, 3 };
Array myArray=Array.CreateInstance( typeof(string), myLengthsArray, myBoundsArray );
for ( int i = myArray.GetLowerBound(0); i <= myArray.GetUpperBound(0); i++ )
for ( int j = myArray.GetLowerBound(1); j <= myArray.GetUpperBound(1); j++ ) {
int[] myIndicesArray = new int[2] { i, j };
myArray.SetValue( Convert.ToString(i) + j, myIndicesArray );
}
// Displays the lower bounds and the upper bounds of each dimension.
Console.WriteLine( "Bounds:\tLower\tUpper" );
for ( int i = 0; i < myArray.Rank; i++ )
Console.WriteLine( "{0}:\t{1}\t{2}", i, myArray.GetLowerBound(i), myArray.GetUpperBound(i) );
// Displays the values of the Array.
Console.WriteLine( "The Array contains the following values:" );
PrintValues( myArray );
}
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.
Bounds: Lower Upper
0: 2 4
1: 3 7
The Array contains the following values:
23 24 25 26 27
33 34 35 36 37
43 44 45 46 47
*/
using System;
public class SamplesArray4 {
public static void Main() {
// Creates and initializes a multidimensional Array of type string.
int[] myLengthsArray = new int[2] { 3, 5 };
int[] myBoundsArray = new int[2] { 2, 3 };
Array myArray=Array.CreateInstance( typeof(string), myLengthsArray, myBoundsArray );
for ( int i = myArray.GetLowerBound(0); i <= myArray.GetUpperBound(0); i++ )
for ( int j = myArray.GetLowerBound(1); j <= myArray.GetUpperBound(1); j++ ) {
int[] myIndicesArray = new int[2] { i, j };
myArray.SetValue( Convert.ToString(i) + j, myIndicesArray );
}
// Displays the lower bounds and the upper bounds of each dimension.
Console.WriteLine( "Bounds:\tLower\tUpper" );
for ( int i = 0; i < myArray.Rank; i++ )
Console.WriteLine( "{0}:\t{1}\t{2}", i, myArray.GetLowerBound(i), myArray.GetUpperBound(i) );
// Displays the values of the Array.
Console.WriteLine( "The Array contains the following values:" );
PrintValues( myArray );
}
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.
Bounds: Lower Upper
0: 2 4
1: 3 7
The Array contains the following values:
23 24 25 26 27
33 34 35 36 37
43 44 45 46 47
*/
Commenti
A differenza della maggior parte delle classi, Array fornisce il CreateInstance metodo , anziché i costruttori pubblici, per consentire l'accesso con associazione tardiva.
Le lengths matrici e lowerBounds devono avere lo stesso numero di elementi. Il numero di elementi nella lengths matrice deve essere uguale al numero di dimensioni nel nuovo Arrayoggetto .
Ogni elemento della lengths matrice deve specificare la lunghezza della dimensione corrispondente nel nuovo Arrayoggetto .
Ogni elemento della lowerBounds matrice deve specificare il limite inferiore della dimensione corrispondente nel nuovo Arrayoggetto . In genere, la libreria di classi .NET e molti linguaggi di programmazione non gestiscono limiti inferiori diversi da zero.
Gli elementi di tipo riferimento vengono inizializzati in null. Gli elementi di tipo valore vengono inizializzati su zero.
Questo metodo è un'operazione O(n), dove n è il prodotto di tutti i valori in lengths.
Nota
Non tutti i linguaggi supportano matrici con limiti inferiori diversi da zero e pertanto potrebbe non essere possibile eseguire il cast di istanze di non zero in base Array al tipo di matrice del linguaggio. Ad esempio, non è possibile eseguire il cast di una matrice integer bidimensionale con il limite inferiore 6 al tipo di int[] C#. In questo modo durante il runtime viene visualizzato InvalidCastException il messaggio "Impossibile eseguire il cast dell'oggetto di tipo "System.Int32[*]" per digitare "System.Int32[]".", dove l'asterisco (*) indica un indice in base diverso da zero. È tuttavia possibile eseguire il cast di matrici in base zero di qualsiasi rango creato con CreateInstance(Type, Int32[], Int32[]) nella matrice del linguaggio. Ad esempio, è possibile eseguire il cast di una matrice integer a base zero bidimensionale creata con questo metodo al tipo di int[,] C#.
Si applica a
CreateInstance(Type, Int32, Int32, Int32)
- Source:
- Array.cs
- Source:
- Array.cs
- Source:
- Array.cs
public:
static Array ^ CreateInstance(Type ^ elementType, int length1, int length2, int length3);public static Array CreateInstance (Type elementType, int length1, int length2, int length3);static member CreateInstance : Type * int * int * int -> ArrayPublic Shared Function CreateInstance (elementType As Type, length1 As Integer, length2 As Integer, length3 As Integer) As ArrayParametri
Restituisce
Nuovo oggetto Array tridimensionale dell'oggetto Type specificato con la lunghezza specificata per ciascuna dimensione, con indice in base zero.
Eccezioni
elementType è null.
elementType non è un oggetto Type valido.
elementType non è supportato. Ad esempio, Void non è supportato.
-oppure-
elementType è un tipo generico aperto.
length1 è minore di zero.
-oppure-
length2 è minore di zero.
-oppure-
length3 è minore di zero.
Esempio
Nell'esempio di codice seguente viene illustrato come creare e inizializzare un oggetto tridimensionale Array.
using namespace System;
void PrintValues( Array^ myArr );
void main()
{
// Creates and initializes a three-dimensional Array instance of type Object.
Array^ my3DArray = Array::CreateInstance( Object::typeid, 2, 3, 4 );
for ( int i = my3DArray->GetLowerBound( 0 ); i <= my3DArray->GetUpperBound( 0 ); i++ )
for ( int j = my3DArray->GetLowerBound( 1 ); j <= my3DArray->GetUpperBound( 1 ); j++ )
for ( int k = my3DArray->GetLowerBound( 2 ); k <= my3DArray->GetUpperBound( 2 ); k++ )
my3DArray->SetValue( String::Concat( "abc", i, j, k ), i, j, k );
// Displays the values of the Array.
Console::WriteLine( "The three-dimensional Array instance contains the following values:" );
PrintValues( my3DArray );
}
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 three-dimensional Array instance contains the following values:
abc000 abc001 abc002 abc003
abc010 abc011 abc012 abc013
abc020 abc021 abc022 abc023
abc100 abc101 abc102 abc103
abc110 abc111 abc112 abc113
abc120 abc121 abc122 abc123
*/
open System
let printValues (myArray: Array) =
let mutable i = 0
let cols = myArray.GetLength(myArray.Rank - 1)
for item in myArray do
if i < cols then
i <- i + 1
else
printfn ""
i <- 1;
printf $"\t{item}"
printfn ""
// Creates and initializes a three-dimensional Array of type Object.
let my3DArray = Array.CreateInstance(typeof<obj>, 2, 3, 4 )
// let my3dArray = Array3D.zeroCreate<obj> 2 3 4
for i = my3DArray.GetLowerBound 0 to my3DArray.GetUpperBound 0 do
for j = my3DArray.GetLowerBound 1 to my3DArray.GetUpperBound 1 do
for k = my3DArray.GetLowerBound 2 to my3DArray.GetUpperBound 2 do
my3DArray.SetValue($"abc{i}{j}{k}", i, j, k)
// Displays the values of the Array.
printfn "The three-dimensional Array contains the following values:"
printValues my3DArray
// This code produces the following output.
// The three-dimensional Array contains the following values:
// abc000 abc001 abc002 abc003
// abc010 abc011 abc012 abc013
// abc020 abc021 abc022 abc023
// abc100 abc101 abc102 abc103
// abc110 abc111 abc112 abc113
// abc120 abc121 abc122 abc123
using System;
public class SamplesArray2 {
public static void Main() {
// Creates and initializes a three-dimensional Array of type Object.
Array my3DArray=Array.CreateInstance( typeof(Object), 2, 3, 4 );
for ( int i = my3DArray.GetLowerBound(0); i <= my3DArray.GetUpperBound(0); i++ )
for ( int j = my3DArray.GetLowerBound(1); j <= my3DArray.GetUpperBound(1); j++ )
for ( int k = my3DArray.GetLowerBound(2); k <= my3DArray.GetUpperBound(2); k++ )
my3DArray.SetValue( "abc" + i + j + k, i, j, k );
// Displays the values of the Array.
Console.WriteLine( "The three-dimensional Array contains the following values:" );
PrintValues( my3DArray );
}
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 three-dimensional Array contains the following values:
abc000 abc001 abc002 abc003
abc010 abc011 abc012 abc013
abc020 abc021 abc022 abc023
abc100 abc101 abc102 abc103
abc110 abc111 abc112 abc113
abc120 abc121 abc122 abc123
*/
Public Class SamplesArray
Public Shared Sub Main()
' Creates and initializes a three-dimensional Array of type Object.
Dim my3DArray As Array = Array.CreateInstance(GetType(Object), 2, 3, 4)
Dim i As Integer
For i = my3DArray.GetLowerBound(0) To my3DArray.GetUpperBound(0)
Dim j As Integer
For j = my3DArray.GetLowerBound(1) To my3DArray.GetUpperBound(1)
Dim k As Integer
For k = my3DArray.GetLowerBound(2) To my3DArray.GetUpperBound(2)
my3DArray.SetValue("abc" + i.ToString() _
+ j.ToString() + k.ToString(), i, j, k)
Next k
Next j
Next i
' Displays the values of the Array.
Console.WriteLine("The three-dimensional Array contains the " _
+ "following values:")
PrintValues(my3DArray)
End Sub
Public Shared Sub PrintValues(myArr As Array)
Dim myEnumerator As System.Collections.IEnumerator = _
myArr.GetEnumerator()
Dim i As Integer = 0
Dim cols As Integer = myArr.GetLength(myArr.Rank - 1)
While myEnumerator.MoveNext()
If i < cols Then
i += 1
Else
Console.WriteLine()
i = 1
End If
Console.Write(ControlChars.Tab + "{0}", myEnumerator.Current)
End While
Console.WriteLine()
End Sub
End Class
' This code produces the following output.
'
' The three-dimensional Array contains the following values:
' abc000 abc001 abc002 abc003
' abc010 abc011 abc012 abc013
' abc020 abc021 abc022 abc023
' abc100 abc101 abc102 abc103
' abc110 abc111 abc112 abc113
' abc120 abc121 abc122 abc123
Commenti
A differenza della maggior parte delle classi, Array fornisce il CreateInstance metodo , anziché i costruttori pubblici, per consentire l'accesso con associazione tardiva.
Gli elementi di tipo riferimento vengono inizializzati in null. Gli elementi di tipo valore vengono inizializzati su zero.
Questo metodo è un'operazione O(n), dove n è il prodotto di length1, length2e length3.
In F# è invece possibile usare la funzione Array3D.zeroCreate .
Si applica a
Commenti e suggerimenti
Presto disponibile: nel corso del 2024 verranno dismessi i problemi di GitHub come meccanismo di feedback per il contenuto e verranno sostituiti con un nuovo sistema di feedback. Per altre informazioni, vedere: https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per