Array.CreateInstance Metoda
Definicja
Przeciążenia
| CreateInstance(Type, Int32) |
Tworzy jednowymiarową Array określoną Type długość i z indeksowaniem opartym na zero.Creates a one-dimensional Array of the specified Type and length, with zero-based indexing. |
| CreateInstance(Type, Int32[]) |
Tworzy wielowymiarową Array określoną Type długość i długości wymiarów przy użyciu indeksowania od zera.Creates a multidimensional Array of the specified Type and dimension lengths, with zero-based indexing. Długości wymiarów są określone w tablicy 32-bitowych liczb całkowitych.The dimension lengths are specified in an array of 32-bit integers. |
| CreateInstance(Type, Int64[]) |
Tworzy wielowymiarową Array określoną Type długość i długości wymiarów przy użyciu indeksowania od zera.Creates a multidimensional Array of the specified Type and dimension lengths, with zero-based indexing. Długości wymiarów są określone w tablicy 64-bitowych liczb całkowitych.The dimension lengths are specified in an array of 64-bit integers. |
| CreateInstance(Type, Int32, Int32) |
Tworzy dwuwymiarową Array określoną Type długość i długości wymiarów przy użyciu indeksowania od zera.Creates a two-dimensional Array of the specified Type and dimension lengths, with zero-based indexing. |
| CreateInstance(Type, Int32[], Int32[]) |
Tworzy wielowymiarowy Array określony Type i długości wymiaru z określonymi dolnymi granicami.Creates a multidimensional Array of the specified Type and dimension lengths, with the specified lower bounds. |
| CreateInstance(Type, Int32, Int32, Int32) |
Tworzy trójwymiarowe Array wartości określone Type i długości wymiarów przy użyciu indeksowania od zera.Creates a three-dimensional Array of the specified Type and dimension lengths, with zero-based indexing. |
CreateInstance(Type, Int32)
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 ArrayParametry
Zwraca
Nowe jednowymiarowe Array o określonej Type długości przy użyciu indeksowania opartego na zero.A new one-dimensional Array of the specified Type with the specified length, using zero-based indexing.
Wyjątki
elementType to null.elementType is null.
elementType nie jest obsługiwana.elementType is not supported. Na przykład adres Voidnie jest obsługiwany.For example, Void is not supported.
-lub--or-
elementType jest otwartym typem ogólnym.elementType is an open generic type.
Parametr length ma wartość niższą niż zero.length is less than zero.
Przykłady
Poniższy przykład kodu pokazuje, jak utworzyć i zainicjować jednowymiarowo Array .The following code example shows how to create and initialize a one-dimensional 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
*/
using System;
public class SamplesArray {
public static void Main() {
// Creates and initializes a one-dimensional Array of type Int32.
Array my1DArray=Array.CreateInstance( typeof(Int32), 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
Uwagi
W przeciwieństwie do większości klas, Array zapewnia CreateInstance metodę zamiast konstruktorów publicznych, aby umożliwić dostęp z późnym wiązaniem.Unlike most classes, Array provides the CreateInstance method, instead of public constructors, to allow for late bound access.
Elementy typu odwołania są inicjowane do null .Reference-type elements are initialized to null. Elementy typu wartości są inicjowane od zera.Value-type elements are initialized to zero.
Ta metoda jest n operacją o (), gdzie n is length .This method is an O(n) operation, where n is length.
Dotyczy
CreateInstance(Type, Int32[])
Tworzy wielowymiarową Array określoną Type długość i długości wymiarów przy użyciu indeksowania od zera.Creates a multidimensional Array of the specified Type and dimension lengths, with zero-based indexing. Długości wymiarów są określone w tablicy 32-bitowych liczb całkowitych.The dimension lengths are specified in an array of 32-bit integers.
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 ArrayParametry
- lengths
- Int32[]
Tablica 32-bitowych liczb całkowitych reprezentujących rozmiar każdego wymiaru Array do utworzenia.An array of 32-bit integers that represent the size of each dimension of the Array to create.
Zwraca
Nowy wielowymiarowy Array określony Type z określoną długością dla każdego wymiaru, przy użyciu indeksowania opartego na zero.A new multidimensional Array of the specified Type with the specified length for each dimension, using zero-based indexing.
Wyjątki
elementType to null.elementType is null.
-lub--or-
lengths to null.lengths is null.
elementType jest nieprawidłowy Type .elementType is not a valid Type.
-lub--or-
lengthsTablica zawiera mniej niż jeden element.The lengths array contains less than one element.
elementType nie jest obsługiwana.elementType is not supported. Na przykład adres Voidnie jest obsługiwany.For example, Void is not supported.
-lub--or-
elementType jest otwartym typem ogólnym.elementType is an open generic type.
Wartość w lengths jest mniejsza od zera.Any value in lengths is less than zero.
Przykłady
Poniższy przykład kodu pokazuje, jak utworzyć i zainicjować wielowymiarowy Array .The following code example shows how to create and initialize a multidimensional 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
*/
using System;
public class SamplesArray {
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
Uwagi
W przeciwieństwie do większości klas, Array zapewnia CreateInstance metodę zamiast konstruktorów publicznych, aby umożliwić dostęp z późnym wiązaniem.Unlike most classes, Array provides the CreateInstance method, instead of public constructors, to allow for late bound access.
Liczba elementów w lengths tablicy musi być równa liczbie wymiarów w nowym Array .The number of elements in the lengths array must equal the number of dimensions in the new Array. Każdy element lengths tablicy musi określać długość odpowiedniego wymiaru w nowym Array .Each element of the lengths array must specify the length of the corresponding dimension in the new Array.
Elementy typu odwołania są inicjowane do null .Reference-type elements are initialized to null. Elementy typu wartości są inicjowane od zera.Value-type elements are initialized to zero.
Ta metoda jest n operacją o (), gdzie n jest iloczynem wszystkich wartości w lengths .This method is an O(n) operation, where n is the product of all values in lengths.
Dotyczy
CreateInstance(Type, Int64[])
Tworzy wielowymiarową Array określoną Type długość i długości wymiarów przy użyciu indeksowania od zera.Creates a multidimensional Array of the specified Type and dimension lengths, with zero-based indexing. Długości wymiarów są określone w tablicy 64-bitowych liczb całkowitych.The dimension lengths are specified in an array of 64-bit integers.
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 ArrayParametry
- lengths
- Int64[]
Tablica 64-bitowych liczb całkowitych reprezentujących rozmiar każdego wymiaru Array do utworzenia.An array of 64-bit integers that represent the size of each dimension of the Array to create. Każda liczba całkowita w tablicy musi się mieścić w przedziale od 0 do MaxValue włącznie.Each integer in the array must be between zero and MaxValue, inclusive.
Zwraca
Nowy wielowymiarowy Array określony Type z określoną długością dla każdego wymiaru, przy użyciu indeksowania opartego na zero.A new multidimensional Array of the specified Type with the specified length for each dimension, using zero-based indexing.
Wyjątki
elementType to null.elementType is null.
-lub--or-
lengths to null.lengths is null.
elementType jest nieprawidłowy Type .elementType is not a valid Type.
-lub--or-
lengthsTablica zawiera mniej niż jeden element.The lengths array contains less than one element.
elementType nie jest obsługiwana.elementType is not supported. Na przykład adres Voidnie jest obsługiwany.For example, Void is not supported.
-lub--or-
elementType jest otwartym typem ogólnym.elementType is an open generic type.
Wartość w lengths jest mniejsza od zera lub większa niż MaxValue .Any value in lengths is less than zero or greater than MaxValue.
Przykłady
Poniższy przykład kodu pokazuje, jak utworzyć i zainicjować wielowymiarowy Array .The following code example shows how to create and initialize a multidimensional 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
*/
using System;
public class SamplesArray {
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
Uwagi
W przeciwieństwie do większości klas, Array zapewnia CreateInstance metodę zamiast konstruktorów publicznych, aby umożliwić dostęp z późnym wiązaniem.Unlike most classes, Array provides the CreateInstance method, instead of public constructors, to allow for late bound access.
Liczba elementów w lengths tablicy musi być równa liczbie wymiarów w nowym Array .The number of elements in the lengths array must equal the number of dimensions in the new Array. Każdy element lengths tablicy musi określać długość odpowiedniego wymiaru w nowym Array .Each element of the lengths array must specify the length of the corresponding dimension in the new Array.
Elementy typu odwołania są inicjowane do null .Reference-type elements are initialized to null. Elementy typu wartości są inicjowane od zera.Value-type elements are initialized to zero.
Ta metoda jest n operacją o (), gdzie n jest iloczynem wszystkich wartości w lengths .This method is an O(n) operation, where n is the product of all values in lengths.
Dotyczy
CreateInstance(Type, Int32, Int32)
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 ArrayParametry
- length1
- Int32
Rozmiar pierwszego wymiaru, Array który ma zostać utworzony.The size of the first dimension of the Array to create.
- length2
- Int32
Rozmiar drugiego wymiaru, Array który ma zostać utworzony.The size of the second dimension of the Array to create.
Zwraca
Nowe dwuwymiarowe Array o określonej Type długości dla każdego wymiaru przy użyciu indeksowania opartego na zero.A new two-dimensional Array of the specified Type with the specified length for each dimension, using zero-based indexing.
Wyjątki
elementType to null.elementType is null.
elementType nie jest obsługiwana.elementType is not supported. Na przykład adres Voidnie jest obsługiwany.For example, Void is not supported.
-lub--or-
elementType jest otwartym typem ogólnym.elementType is an open generic type.
Parametr length1 ma wartość niższą niż zero.length1 is less than zero.
-lub--or-
Parametr length2 ma wartość niższą niż zero.length2 is less than zero.
Przykłady
Poniższy przykład kodu pokazuje, jak utworzyć i zainicjować dwuwymiarowy Array .The following code example shows how to create and initialize a two-dimensional 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
*/
using System;
public class SamplesArray {
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
Uwagi
W przeciwieństwie do większości klas, Array zapewnia CreateInstance metodę zamiast konstruktorów publicznych, aby umożliwić dostęp z późnym wiązaniem.Unlike most classes, Array provides the CreateInstance method, instead of public constructors, to allow for late bound access.
Elementy typu odwołania są inicjowane do null .Reference-type elements are initialized to null. Elementy typu wartości są inicjowane od zera.Value-type elements are initialized to zero.
Ta metoda jest n operacją o (), gdzie n jest produktem length1 i length2 .This method is an O(n) operation, where n is the product of length1 and length2.
Dotyczy
CreateInstance(Type, Int32[], Int32[])
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 ArrayParametry
- lengths
- Int32[]
Tablica Jednowymiarowa, która zawiera rozmiar każdego wymiaru Array do utworzenia.A one-dimensional array that contains the size of each dimension of the Array to create.
- lowerBounds
- Int32[]
Jednowymiarowa tablica, która zawiera dolną granicę (indeks początkowy) każdego wymiaru Array do utworzenia.A one-dimensional array that contains the lower bound (starting index) of each dimension of the Array to create.
Zwraca
Nowy wielowymiarowy Array określony Type z określoną długością i dolną granicą dla każdego wymiaru.A new multidimensional Array of the specified Type with the specified length and lower bound for each dimension.
Wyjątki
elementType to null.elementType is null.
-lub--or-
lengths to null.lengths is null.
-lub--or-
lowerBounds to null.lowerBounds is null.
elementType jest nieprawidłowy Type .elementType is not a valid Type.
-lub--or-
lengthsTablica zawiera mniej niż jeden element.The lengths array contains less than one element.
-lub--or-
lengthsTablice i nie lowerBounds zawierają tej samej liczby elementów.The lengths and lowerBounds arrays do not contain the same number of elements.
elementType nie jest obsługiwana.elementType is not supported. Na przykład adres Voidnie jest obsługiwany.For example, Void is not supported.
-lub--or-
elementType jest otwartym typem ogólnym.elementType is an open generic type.
Wartość w lengths jest mniejsza od zera.Any value in lengths is less than zero.
-lub--or-
Każda wartość w lowerBounds jest bardzo duża, w taki sposób, aby suma dolnego powiązania wymiaru i długość była większa niż MaxValue .Any value in lowerBounds is very large, such that the sum of a dimension's lower bound and length is greater than MaxValue.
Przykłady
Poniższy przykład kodu pokazuje, jak utworzyć i zainicjować wielowymiarowy Array z określonymi dolnymi granicami.The following code example shows how to create and initialize a multidimensional Array with specified lower bounds.
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
*/
using System;
public class SamplesArray {
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
*/
Public Class SamplesArray
Public Shared Sub Main()
' Creates and initializes a multidimensional Array of type String.
Dim myLengthsArray() As Integer = {3, 5}
Dim myBoundsArray() As Integer = {2, 3}
Dim myArray As Array = Array.CreateInstance(GetType(String), _
myLengthsArray, myBoundsArray)
Dim i, j As Integer
Dim myIndicesArray() As Integer
For i = myArray.GetLowerBound(0) To myArray.GetUpperBound(0)
For j = myArray.GetLowerBound(1) To myArray.GetUpperBound(1)
myIndicesArray = New Integer() {i, j}
myArray.SetValue(i.ToString() + j.ToString(), myIndicesArray)
Next j
Next i
' Displays the lower bounds and the upper bounds of each dimension.
Console.WriteLine("Bounds:" + ControlChars.Tab + "Lower" _
+ ControlChars.Tab + "Upper")
For i = 0 To myArray.Rank - 1
Console.WriteLine("{0}:" + ControlChars.Tab + "{1}" _
+ ControlChars.Tab + "{2}", i, myArray.GetLowerBound(i), _
myArray.GetUpperBound(i))
Next i
' Displays the values of the Array.
Console.WriteLine("The Array contains the following values:")
PrintValues(myArray)
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.
'
' 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
Uwagi
W przeciwieństwie do większości klas, Array zapewnia CreateInstance metodę zamiast konstruktorów publicznych, aby umożliwić dostęp z późnym wiązaniem.Unlike most classes, Array provides the CreateInstance method, instead of public constructors, to allow for late bound access.
lengthsTablice i lowerBounds muszą mieć taką samą liczbę elementów.The lengths and lowerBounds arrays must have the same number of elements. Liczba elementów w lengths tablicy musi być równa liczbie wymiarów w nowym Array .The number of elements in the lengths array must equal the number of dimensions in the new Array.
Każdy element lengths tablicy musi określać długość odpowiedniego wymiaru w nowym Array .Each element of the lengths array must specify the length of the corresponding dimension in the new Array.
Każdy element lowerBounds tablicy musi określać dolną granicę odpowiadającego mu wymiaru w nowym Array .Each element of the lowerBounds array must specify the lower bound of the corresponding dimension in the new Array. Ogólnie rzecz biorąc, Biblioteka klas .NET i wiele języków programowania nie obsługują niższych granic.Generally, the .NET class library and many programming languages do not handle non-zero lower bounds.
Elementy typu odwołania są inicjowane do null .Reference-type elements are initialized to null. Elementy typu wartości są inicjowane od zera.Value-type elements are initialized to zero.
Ta metoda jest n operacją o (), gdzie n jest iloczynem wszystkich wartości w lengths .This method is an O(n) operation, where n is the product of all values in lengths.
Uwaga
Nie wszystkie języki obsługują tablice o dolnych granicach innych niż zero, w związku z czym nie można rzutować wystąpień innych niż zero na podstawie Array typu tablicy języka.Not all languages support arrays with non-zero lower bounds, and therefore you may not be able to cast instances of non-zero based Array to the language's array type. Na przykład nie można rzutować tablicy 1-wymiarowej liczby całkowitej z dolną granicą 6 do int[] typu C#.For example, you cannot cast a 1-dimensional integer array with the lower bound 6 to C#'s int[] type. Powoduje to InvalidCastException przełączenie w czasie wykonywania z komunikatem "nie można rzutować obiektu typu System. Int32 [ * ]" na typ "System. Int32 []". ", gdzie gwiazdka ( * ) oznacza indeks niebędący zerem.This results in InvalidCastException during runtime with the message "Unable to cast object of type 'System.Int32[*]' to type 'System.Int32[]'.", where the asterisk (*) means non-zero based index. Możliwe jest jednak rzutowanie tablic opartych na zerowej rangi utworzonej w ramach CreateInstance(Type, Int32[], Int32[]) tablicy języka.However, you can cast zero based arrays of any rank created with CreateInstance(Type, Int32[], Int32[]) to the language's array. Na przykład można rzutować dwuwymiarową tablicę liczbową zero, która została utworzona za pomocą tej metody do int[,] typu C#.For example, you can cast a 2-dimensional zero based integer array created with this method to C#'s int[,] type.
Dotyczy
CreateInstance(Type, Int32, Int32, Int32)
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 ArrayParametry
- length1
- Int32
Rozmiar pierwszego wymiaru, Array który ma zostać utworzony.The size of the first dimension of the Array to create.
- length2
- Int32
Rozmiar drugiego wymiaru, Array który ma zostać utworzony.The size of the second dimension of the Array to create.
- length3
- Int32
Rozmiar trzeciego wymiaru, Array który ma zostać utworzony.The size of the third dimension of the Array to create.
Zwraca
Nowe trzy wymiary z określoną Array Type długością dla każdego wymiaru przy użyciu indeksowania opartego na zero.A new three-dimensional Array of the specified Type with the specified length for each dimension, using zero-based indexing.
Wyjątki
elementType to null.elementType is null.
elementType nie jest obsługiwana.elementType is not supported. Na przykład adres Voidnie jest obsługiwany.For example, Void is not supported.
-lub--or-
elementType jest otwartym typem ogólnym.elementType is an open generic type.
Parametr length1 ma wartość niższą niż zero.length1 is less than zero.
-lub--or-
Parametr length2 ma wartość niższą niż zero.length2 is less than zero.
-lub--or-
Parametr length3 ma wartość niższą niż zero.length3 is less than zero.
Przykłady
Poniższy przykład kodu pokazuje, jak utworzyć i zainicjować trójwymiarowy Array .The following code example shows how to create and initialize a three-dimensional 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
*/
using System;
public class SamplesArray {
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
Uwagi
W przeciwieństwie do większości klas, Array zapewnia CreateInstance metodę zamiast konstruktorów publicznych, aby umożliwić dostęp z późnym wiązaniem.Unlike most classes, Array provides the CreateInstance method, instead of public constructors, to allow for late bound access.
Elementy typu odwołania są inicjowane do null .Reference-type elements are initialized to null. Elementy typu wartości są inicjowane od zera.Value-type elements are initialized to zero.
Ta metoda jest n operacją o (), gdzie n jest produktem length1 , length2 , i length3 .This method is an O(n) operation, where n is the product of length1, length2, and length3.