Udostępnij za pośrednictwem


Array.CreateInstance Metoda

Definicja

Inicjuje nowe wystąpienie klasy Array.

Przeciążenia

CreateInstance(Type, Int32)

Tworzy jednowymiarową Array określoną Type i długość z indeksowaniem zerowym.

CreateInstance(Type, Int32[])

Tworzy wielowymiarową Array długość określonego Type wymiaru i z indeksowaniem zerowym. Długości wymiarów są określane w tablicy 32-bitowych liczb całkowitych.

CreateInstance(Type, Int64[])

Tworzy wielowymiarową Array długość określonego Type wymiaru i z indeksowaniem zerowym. Długości wymiarów są określane w tablicy 64-bitowych liczb całkowitych.

CreateInstance(Type, Int32, Int32)

Tworzy dwuwymiarową Array długość określonego Type wymiaru i z indeksowaniem zerowym.

CreateInstance(Type, Int32[], Int32[])

Tworzy wielowymiarowe Array długości określonego Type i wymiarowego z określonymi dolnymi granicami.

CreateInstance(Type, Int32, Int32, Int32)

Tworzy trójwymiarową Array długość określonego Type wymiaru i z indeksowaniem zerowym.

CreateInstance(Type, Int32)

Źródło:
Array.cs
Źródło:
Array.cs
Źródło:
Array.cs

Tworzy jednowymiarową Array określoną Type i długość z indeksowaniem zerowym.

public:
 static Array ^ CreateInstance(Type ^ elementType, int length);
public static Array CreateInstance (Type elementType, int length);
static member CreateInstance : Type * int -> Array
Public Shared Function CreateInstance (elementType As Type, length As Integer) As Array

Parametry

elementType
Type

Element Type do utworzenia Array .

length
Int32

Rozmiar obiektu do utworzenia Array .

Zwraca

Nowa jednowymiarowa Array określona Type długość przy użyciu indeksowania zerowego.

Wyjątki

elementType to null.

elementType element nie jest prawidłowym Typeelementem .

elementType program nie jest obsługiwany. Na przykład adres Voidnie jest obsługiwany.

-lub-

elementType jest otwartym typem ogólnym.

Parametr length ma wartość niższą niż zero.

Przykłady

W poniższym przykładzie kodu pokazano, jak utworzyć i zainicjować jednowymiarowy Arrayobiekt .

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

Uwagi

W przeciwieństwie do większości klas metoda Array udostępnia metodę CreateInstance zamiast konstruktorów publicznych, aby umożliwić dostęp do późnego ograniczenia.

Elementy typu odwołania są inicjowane do elementu null. Elementy typu wartości są inicjowane od zera.

Ta metoda jest operacją O(n), gdzie n to length.

W języku F# funkcja Array.zeroCreate jest zwykle używana.

Dotyczy

CreateInstance(Type, Int32[])

Źródło:
Array.cs
Źródło:
Array.cs
Źródło:
Array.cs

Tworzy wielowymiarową Array długość określonego Type wymiaru i z indeksowaniem zerowym. Długości wymiarów są określane w tablicy 32-bitowych liczb całkowitych.

public:
 static Array ^ CreateInstance(Type ^ elementType, ... cli::array <int> ^ lengths);
public static Array CreateInstance (Type elementType, params int[] lengths);
static member CreateInstance : Type * int[] -> Array
Public Shared Function CreateInstance (elementType As Type, ParamArray lengths As Integer()) As Array

Parametry

elementType
Type

Element Type do utworzenia Array .

lengths
Int32[]

Tablica 32-bitowych liczb całkowitych reprezentująca rozmiar każdego wymiaru do utworzenia Array .

Zwraca

Nowa wielowymiarowa Array wartość określona Type z określoną długością dla każdego wymiaru przy użyciu indeksowania zerowego.

Wyjątki

elementType to null.

-lub-

lengths to null.

elementType element nie jest prawidłowym Typeelementem .

-lub-

Tablica lengths zawiera mniej niż jeden element.

elementType program nie jest obsługiwany. Na przykład adres Voidnie jest obsługiwany.

-lub-

elementType jest otwartym typem ogólnym.

Każda wartość w elemecie lengths jest mniejsza niż zero.

Przykłady

W poniższym przykładzie kodu pokazano, jak utworzyć i zainicjować wielowymiarowy Arrayelement .

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

Uwagi

W przeciwieństwie do większości klas metoda Array udostępnia metodę CreateInstance zamiast konstruktorów publicznych, aby umożliwić dostęp do późnego ograniczenia.

Liczba elementów w lengths tablicy musi być równa liczbie wymiarów w nowym Arrayobiekcie . Każdy element lengths tablicy musi określać długość odpowiedniego wymiaru w nowym Arrayobiekcie .

Elementy typu odwołania są inicjowane do elementu null. Elementy typu wartości są inicjowane od zera.

Ta metoda jest operacją O(n), gdzie n jest iloczynem wszystkich wartości w .lengths

Dotyczy

CreateInstance(Type, Int64[])

Źródło:
Array.cs
Źródło:
Array.cs
Źródło:
Array.cs

Tworzy wielowymiarową Array długość określonego Type wymiaru i z indeksowaniem zerowym. Długości wymiarów są określane w tablicy 64-bitowych liczb całkowitych.

public:
 static Array ^ CreateInstance(Type ^ elementType, ... cli::array <long> ^ lengths);
public static Array CreateInstance (Type elementType, params long[] lengths);
static member CreateInstance : Type * int64[] -> Array
Public Shared Function CreateInstance (elementType As Type, ParamArray lengths As Long()) As Array

Parametry

elementType
Type

Element Type do utworzenia Array .

lengths
Int64[]

Tablica 64-bitowych liczb całkowitych reprezentujących rozmiar każdego wymiaru do utworzenia Array . Każda liczba całkowita w tablicy musi należeć do zakresu od zera do int32.MaxValue włącznie.

Zwraca

Nowa wielowymiarowa Array wartość określona Type z określoną długością dla każdego wymiaru przy użyciu indeksowania zerowego.

Wyjątki

elementType to null.

-lub-

lengths to null.

elementType element nie jest prawidłowym Typeelementem .

-lub-

Tablica lengths zawiera mniej niż jeden element.

elementType program nie jest obsługiwany. Na przykład adres Voidnie jest obsługiwany.

-lub-

elementType jest otwartym typem ogólnym.

Dowolna wartość w elemecie lengths jest mniejsza niż zero lub większa niż Int32.MaxValue.

Przykłady

W poniższym przykładzie kodu pokazano, jak utworzyć i zainicjować wielowymiarowy Arrayelement .

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

Uwagi

W przeciwieństwie do większości klas metoda Array udostępnia metodę CreateInstance zamiast konstruktorów publicznych, aby umożliwić dostęp do późnego ograniczenia.

Liczba elementów w lengths tablicy musi być równa liczbie wymiarów w nowym Arrayobiekcie . Każdy element lengths tablicy musi określać długość odpowiedniego wymiaru w nowym Arrayobiekcie .

Elementy typu odwołania są inicjowane do elementu null. Elementy typu wartości są inicjowane od zera.

Ta metoda jest operacją O(n), gdzie n jest iloczynem wszystkich wartości w .lengths

Dotyczy

CreateInstance(Type, Int32, Int32)

Źródło:
Array.cs
Źródło:
Array.cs
Źródło:
Array.cs

Tworzy dwuwymiarową Array długość określonego Type wymiaru i z indeksowaniem zerowym.

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 -> Array
Public Shared Function CreateInstance (elementType As Type, length1 As Integer, length2 As Integer) As Array

Parametry

elementType
Type

Element Type do utworzenia Array .

length1
Int32

Rozmiar pierwszego wymiaru do utworzenia Array .

length2
Int32

Rozmiar drugiego wymiaru elementu do utworzenia Array .

Zwraca

Nowy dwuwymiarowy Array element określony Type o określonej długości dla każdego wymiaru przy użyciu indeksowania opartego na zera.

Wyjątki

elementType to null.

elementType element nie jest prawidłowym Typeelementem .

elementType program nie jest obsługiwany. Na przykład adres Voidnie jest obsługiwany.

-lub-

elementType jest otwartym typem ogólnym.

Parametr length1 ma wartość niższą niż zero.

-lub-

Parametr length2 ma wartość niższą niż zero.

Przykłady

W poniższym przykładzie kodu pokazano, jak utworzyć i zainicjować dwuwymiarowy Arrayelement .

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

Uwagi

W przeciwieństwie do większości klas metoda Array udostępnia metodę CreateInstance zamiast konstruktorów publicznych, aby umożliwić dostęp do późnego ograniczenia.

Elementy typu odwołania są inicjowane do elementu null. Elementy typu wartości są inicjowane od zera.

Ta metoda jest operacją O(n), gdzie n jest produktem length1 i length2.

W języku F# można zamiast tego użyć funkcji Array2D.zeroCreate .

Dotyczy

CreateInstance(Type, Int32[], Int32[])

Źródło:
Array.cs
Źródło:
Array.cs
Źródło:
Array.cs

Tworzy wielowymiarowe Array długości określonego Type wymiaru i z określonymi dolnymi granicami.

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[] -> Array
Public Shared Function CreateInstance (elementType As Type, lengths As Integer(), lowerBounds As Integer()) As Array

Parametry

elementType
Type

Element Type do utworzenia Array .

lengths
Int32[]

Tablica jednowymiarowa zawierająca rozmiar każdego wymiaru do Array utworzenia.

lowerBounds
Int32[]

Tablica jednowymiarowa zawierająca dolną granicę (indeks początkowy) każdego wymiaru do utworzenia Array .

Zwraca

Nowa wielowymiarowa Array wartość określona Type o określonej długości i niższej granicy dla każdego wymiaru.

Wyjątki

elementType to null.

-lub-

lengths to null.

-lub-

lowerBounds to null.

elementType nie jest prawidłowym Typeelementem .

-lub-

Tablica lengths zawiera mniej niż jeden element.

-lub-

Tablice lengths i lowerBounds nie zawierają tej samej liczby elementów.

elementType nie jest obsługiwane. Na przykład adres Voidnie jest obsługiwany.

-lub-

elementType jest otwartym typem ogólnym.

Każda wartość w elemecie lengths jest mniejsza niż zero.

-lub-

Każda wartość w elemecie lowerBounds jest bardzo duża, tak że suma niższej granicy wymiaru i długość jest większa niż Int32.MaxValue.

Przykłady

Poniższy przykład kodu pokazuje, jak utworzyć i zainicjować wielowymiarowe Array z określonymi dolnymi granicami.

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

Uwagi

W przeciwieństwie do większości klas, Array zapewnia metodę CreateInstance , zamiast konstruktorów publicznych, aby umożliwić dostęp z opóźnieniem.

Tablice lengths i lowerBounds muszą mieć taką samą liczbę elementów. Liczba elementów w lengths tablicy musi być równa liczbie wymiarów w nowym Arrayobiekcie .

Każdy element tablicy lengths musi określać długość odpowiedniego wymiaru w nowym Arrayobiekcie .

Każdy element tablicy lowerBounds musi określać dolną granicę odpowiedniego wymiaru w nowym Arrayobiekcie . Ogólnie rzecz biorąc, biblioteka klas platformy .NET i wiele języków programowania nie obsługują niezerowych niższych granic.

Elementy typu odwołania są inicjowane do nullelementu . Elementy typu wartości są inicjowane od zera.

Ta metoda jest operacją O(n), gdzie n jest produktem wszystkich wartości w elemecie lengths.

Uwaga

Nie wszystkie języki obsługują tablice z niezerowymi dolnymi granicami, dlatego nie można rzutować wystąpień niezerowych na podstawie Array typu tablicy języka. Na przykład nie można rzutować 1-wymiarowej tablicy całkowitej z dolną granicą 6 na typ języka C# int[] . InvalidCastException Spowoduje to wyświetlenie komunikatu "Nie można rzutować obiektu typu System.Int32[*]", aby wpisać "System.Int32[]".", gdzie gwiazdka (*) oznacza indeks niezerowy. Można jednak rzutować tablice zero oparte na dowolnej rangi utworzonej z CreateInstance(Type, Int32[], Int32[]) tablicą języka. Na przykład można rzutować tablicę całkowitą opartą na 2 wymiarach utworzoną za pomocą tej metody do typu języka C# int[,] .

Dotyczy

CreateInstance(Type, Int32, Int32, Int32)

Źródło:
Array.cs
Źródło:
Array.cs
Źródło:
Array.cs

Tworzy trójwymiarową Array długość określonego Type wymiaru i z indeksowaniem zerowym.

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 -> Array
Public Shared Function CreateInstance (elementType As Type, length1 As Integer, length2 As Integer, length3 As Integer) As Array

Parametry

elementType
Type

Element Type do utworzenia Array .

length1
Int32

Rozmiar pierwszego wymiaru do utworzenia Array .

length2
Int32

Rozmiar drugiego wymiaru do utworzenia Array .

length3
Int32

Rozmiar trzeciego wymiaru do utworzenia Array .

Zwraca

Nowa trójwymiarowa trójwymiarowa Array określona Type długość dla każdego wymiaru przy użyciu indeksowania opartego na zera.

Wyjątki

elementType to null.

elementType nie jest prawidłowym Typeelementem .

elementType nie jest obsługiwane. Na przykład adres Voidnie jest obsługiwany.

-lub-

elementType jest otwartym typem ogólnym.

Parametr length1 ma wartość niższą niż zero.

-lub-

Parametr length2 ma wartość niższą niż zero.

-lub-

Parametr length3 ma wartość niższą niż zero.

Przykłady

Poniższy przykład kodu pokazuje, jak utworzyć i zainicjować trójwymiarowy Arrayelement .

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

Uwagi

W przeciwieństwie do większości klas, Array zapewnia metodę CreateInstance , zamiast konstruktorów publicznych, aby umożliwić dostęp z opóźnieniem.

Elementy typu odwołania są inicjowane do nullelementu . Elementy typu wartości są inicjowane od zera.

Ta metoda jest operacją O(n), gdzie n jest produktem length1, length2i length3.

W języku F# można zamiast tego użyć funkcji Array3D.zeroCreate .

Dotyczy