Array.CreateInstance Metódus

Definíció

Névtér:: System

Szerelvények:: mscorlib.dll, System.Runtime.dll

Szerelvények:: netstandard.dll, System.Runtime.dll

Szerelvény:: System.Runtime.dll

Szerelvény:: mscorlib.dll

Szerelvény:: netstandard.dll

Fontos

Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.

Inicializálja a Array osztály új példányát.

Túlterhelések

Name	Description
CreateInstance(Type, Int32)	A megadott Array és a hossz egydimenziós Type létrehozása nulla alapú indexeléssel.
CreateInstance(Type, Int32[])	A megadott Array és dimenzióhosszok többdimenziósát Type hozza létre nulla alapú indexeléssel. A dimenzióhosszok 32 bites egész számokat tartalmazó tömbben vannak megadva.
CreateInstance(Type, Int64[])	A megadott Array és dimenzióhosszok többdimenziósát Type hozza létre nulla alapú indexeléssel. A dimenzióhosszok 64 bites egész számokat tartalmazó tömbben vannak megadva.
CreateInstance(Type, Int32, Int32)	A megadott Array és dimenzióhosszúságok kétdimenziós Type létrehozása nulla alapú indexeléssel.
CreateInstance(Type, Int32[], Int32[])	A megadott Array és a dimenzióhosszok többdimenziósát Type hozza létre a megadott alsó határokkal.
CreateInstance(Type, Int32, Int32, Int32)	A megadott Array és a dimenzióhosszok háromdimenziós Type létrehozása nulla alapú indexeléssel.

CreateInstance(Type, Int32)

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

A megadott Array és a hossz egydimenziós Type létrehozása nulla alapú indexeléssel.

public:
 static Array ^ CreateInstance(Type ^ elementType, int length);

public static Array CreateInstance(Type elementType, int length);

[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("The code for an array of the specified type might not be available.")]
public static Array CreateInstance(Type elementType, int length);

static member CreateInstance : Type * int -> Array

[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("The code for an array of the specified type might not be available.")>]
static member CreateInstance : Type * int -> Array

Public Shared Function CreateInstance (elementType As Type, length As Integer) As Array

Paraméterek

elementType: Type

Type A Array létrehozandók száma.

length: Int32

A létrehozandó méret Array .

Válaszok

Array

A megadott Array hosszú új egydimenziósType, nulla alapú indexelés használatával.

Attribútumok: RequiresDynamicCodeAttribute

Kivételek

ArgumentNullException

elementType az null.

ArgumentException

elementType nem érvényes Type.

NotSupportedException

elementType nem támogatott. Például Void nem támogatott.

-vagy-

elementType egy nyitott általános típus.

ArgumentOutOfRangeException

length kisebb, mint nulla.

Példák

Az alábbi példakód bemutatja, hogyan hozhat létre és inicializálhat egy egydimenziós Arrayobjektumot.

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

Megjegyzések

A legtöbb osztálytól Array eltérően a nyilvános konstruktorok helyett a CreateInstance metódus biztosítja a késői kötésű hozzáférés engedélyezését.

A referencia típusú elemek inicializálása a következőre van inicializálva null: . Az érték típusú elemek nullára vannak inicializálva.

Ez a metódus egy O(n) művelet, ahol n van length.

Az F#-ban általában a Array.zeroCreate függvényt használják.

A következőre érvényes:

CreateInstance(Type, Int32[])

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

A megadott Array és dimenzióhosszok többdimenziósát Type hozza létre nulla alapú indexeléssel. A dimenzióhosszok 32 bites egész számokat tartalmazó tömbben vannak megadva.

public:
 static Array ^ CreateInstance(Type ^ elementType, ... cli::array <int> ^ lengths);

public static Array CreateInstance(Type elementType, params int[] lengths);

[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("The code for an array of the specified type might not be available.")]
public static Array CreateInstance(Type elementType, params int[] lengths);

static member CreateInstance : Type * int[] -> Array

[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("The code for an array of the specified type might not be available.")>]
static member CreateInstance : Type * int[] -> Array

Public Shared Function CreateInstance (elementType As Type, ParamArray lengths As Integer()) As Array

Paraméterek

elementType: Type

Type A Array létrehozandók száma.

lengths: Int32[]

32 bites egész számokat tartalmazó tömb, amely a létrehozandó dimenziók Array méretét jelöli.

Válaszok

Array

A megadott Array érték új többdimenziós értéke az egyes dimenziókhoz Type megadott hosszúságmal, nulla alapú indexelés használatával.

Attribútumok: RequiresDynamicCodeAttribute

Kivételek

ArgumentNullException

elementType az null.

-vagy-

lengths az null.

ArgumentException

elementType nem érvényes Type.

-vagy-

A lengths tömb egynél kevesebb elemet tartalmaz.

NotSupportedException

elementType nem támogatott. Például Void nem támogatott.

-vagy-

elementType egy nyitott általános típus.

ArgumentOutOfRangeException

A benne lévő lengths értékek nullánál kisebbek.

Példák

Az alábbi példakód bemutatja, hogyan hozhat létre és inicializálhat többdimenziós elemet Array.

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

Megjegyzések

A legtöbb osztálytól Array eltérően a nyilvános konstruktorok helyett a CreateInstance metódus biztosítja a késői kötésű hozzáférés engedélyezését.

A tömb elemeinek lengths számának meg kell egyezik az új Arraydimenziók számával. A tömb minden elemének lengths meg kell adnia a megfelelő dimenzió hosszát az újban Array.

A referencia típusú elemek inicializálása a következőre van inicializálva null: . Az érték típusú elemek nullára vannak inicializálva.

Ez a metódus egy O(n) művelet, ahol n a függvény minden értékének szorzata lengths.

A következőre érvényes:

CreateInstance(Type, Int64[])

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

A megadott Array és dimenzióhosszok többdimenziósát Type hozza létre nulla alapú indexeléssel. A dimenzióhosszok 64 bites egész számokat tartalmazó tömbben vannak megadva.

public:
 static Array ^ CreateInstance(Type ^ elementType, ... cli::array <long> ^ lengths);

[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("The code for an array of the specified type might not be available.")]
public static Array CreateInstance(Type elementType, params long[] lengths);

public static Array CreateInstance(Type elementType, params long[] lengths);

[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("The code for an array of the specified type might not be available.")>]
static member CreateInstance : Type * int64[] -> Array

static member CreateInstance : Type * int64[] -> Array

Public Shared Function CreateInstance (elementType As Type, ParamArray lengths As Long()) As Array

Paraméterek

elementType: Type

Type A Array létrehozandók száma.

lengths: Int64[]

64 bites egész számokból álló tömb, amely a létrehozandó dimenziók Array méretét jelöli. A tömb minden egész számának nulla és Int32.MaxValue közöttinek kell lennie, beleértve azokat is.

Válaszok

Array

A megadott Array érték új többdimenziós értéke az egyes dimenziókhoz Type megadott hosszúságmal, nulla alapú indexelés használatával.

Attribútumok: RequiresDynamicCodeAttribute

Kivételek

ArgumentNullException

elementType az null.

-vagy-

lengths az null.

ArgumentException

elementType nem érvényes Type.

-vagy-

A lengths tömb egynél kevesebb elemet tartalmaz.

NotSupportedException

elementType nem támogatott. Például Void nem támogatott.

-vagy-

elementType egy nyitott általános típus.

ArgumentOutOfRangeException

Minden érték lengths kisebb, mint nulla vagy nagyobb, mint az Int32.MaxValue.

Példák

Az alábbi példakód bemutatja, hogyan hozhat létre és inicializálhat többdimenziós elemet Array.

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

Megjegyzések

A legtöbb osztálytól Array eltérően a nyilvános konstruktorok helyett a CreateInstance metódus biztosítja a késői kötésű hozzáférés engedélyezését.

A tömb elemeinek lengths számának meg kell egyezik az új Arraydimenziók számával. A tömb minden elemének lengths meg kell adnia a megfelelő dimenzió hosszát az újban Array.

A referencia típusú elemek inicializálása a következőre van inicializálva null: . Az érték típusú elemek nullára vannak inicializálva.

Ez a metódus egy O(n) művelet, ahol n a függvény minden értékének szorzata lengths.

A következőre érvényes:

CreateInstance(Type, Int32, Int32)

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

A megadott Array és dimenzióhosszúságok kétdimenziós Type létrehozása nulla alapú indexeléssel.

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

Paraméterek

elementType: Type

Type A Array létrehozandók száma.

length1: Int32

A létrehozandó első dimenzió mérete Array .

length2: Int32

A létrehozandó második dimenzió mérete Array .

Válaszok

Array

A megadott Array kétdimenziós érték új kétdimenziósType, az egyes dimenziókhoz megadott hosszúságú, nulla alapú indexeléssel.

Kivételek

ArgumentNullException

elementType az null.

ArgumentException

elementType nem érvényes Type.

NotSupportedException

elementType nem támogatott. Például Void nem támogatott.

-vagy-

elementType egy nyitott általános típus.

ArgumentOutOfRangeException

length1 kisebb, mint nulla.

-vagy-

length2 kisebb, mint nulla.

Példák

Az alábbi példakód bemutatja, hogyan hozhat létre és inicializálhat kétdimenziósokat Array.

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

Megjegyzések

A legtöbb osztálytól Array eltérően a nyilvános konstruktorok helyett a CreateInstance metódus biztosítja a késői kötésű hozzáférés engedélyezését.

A referencia típusú elemek inicializálása a következőre van inicializálva null: . Az érték típusú elemek nullára vannak inicializálva.

Ez a módszer egy O(n) művelet, ahol n az és length1a .length2

Az F#-ban a Array2D.zeroCreate függvény használható helyette.

A következőre érvényes:

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

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

A megadott Array és a dimenzióhosszok többdimenziósát Type hozza létre a megadott alsó határokkal.

public:
 static Array ^ CreateInstance(Type ^ elementType, cli::array <int> ^ lengths, cli::array <int> ^ lowerBounds);

public static Array CreateInstance(Type elementType, int[] lengths, int[] lowerBounds);

[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("The code for an array of the specified type might not be available.")]
public static Array CreateInstance(Type elementType, int[] lengths, int[] lowerBounds);

static member CreateInstance : Type * int[] * int[] -> Array

[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("The code for an array of the specified type might not be available.")>]
static member CreateInstance : Type * int[] * int[] -> Array

Public Shared Function CreateInstance (elementType As Type, lengths As Integer(), lowerBounds As Integer()) As Array

Paraméterek

elementType: Type

Type A Array létrehozandók száma.

lengths: Int32[]

Egydimenziós tömb, amely a létrehozandó dimenziók Array méretét tartalmazza.

lowerBounds: Int32[]

Egydimenziós tömb, amely a létrehozandó dimenziók alsó határát (kezdő indexét Array ) tartalmazza.

Válaszok

Array

A megadott Array többdimenziós érték új többdimenziós, az egyes dimenziókhoz Type megadott hossz és alsó határral.

Attribútumok: RequiresDynamicCodeAttribute

Kivételek

ArgumentNullException

elementType az null.

-vagy-

lengths az null.

-vagy-

lowerBounds az null.

ArgumentException

elementType nem érvényes Type.

-vagy-

A lengths tömb egynél kevesebb elemet tartalmaz.

-vagy-

A lengths tömbök és lowerBounds a tömbök nem azonos számú elemet tartalmaznak.

NotSupportedException

elementType nem támogatott. Például Void nem támogatott.

-vagy-

elementType egy nyitott általános típus.

ArgumentOutOfRangeException

A benne lévő lengths értékek nullánál kisebbek.

-vagy-

Minden érték lowerBounds nagyon nagy, így egy dimenzió alsó határának és hosszának összege nagyobb, mint az Int32.MaxValue.

Példák

Az alábbi példakód bemutatja, hogyan hozhat létre és inicializálhat többdimenziós Array elemet meghatározott alsó határokkal.

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

Megjegyzések

A legtöbb osztálytól Array eltérően a nyilvános konstruktorok helyett a CreateInstance metódus biztosítja a késői kötésű hozzáférés engedélyezését.

A lengths tömböknek azonos lowerBounds számú elemnek kell lenniük. A tömb elemeinek lengths számának meg kell egyezik az új Arraydimenziók számával.

A tömb minden elemének lengths meg kell adnia a megfelelő dimenzió hosszát az újban Array.

A tömb minden elemének lowerBounds meg kell adnia a megfelelő dimenzió alsó határát az újban Array. A .NET osztálykódtár és számos programozási nyelv általában nem kezeli a nullától eltérő alsó határokat.

A referencia típusú elemek inicializálása a következőre van inicializálva null: . Az érték típusú elemek nullára vannak inicializálva.

Ez a metódus egy O(n) művelet, ahol n a függvény minden értékének szorzata lengths.

Note

Nem minden nyelv támogatja a nem nulla alsó határral rendelkező tömböket, ezért előfordulhat, hogy a nyelv tömbtípusa alapján Array nem tudja a nem nulla példányokat leadni. Nem lehet például egy 1 dimenziós egész tömböt leadni, amelynek alsó határa 6 és C# int[] . Ez a futásidőben a InvalidCastException "System.Int32[*]" típusú objektum "System.Int32[]" típusú objektumot nem lehet leadni." üzenet jelenik meg, ahol a csillag (*) nem nulla alapú indexet jelent. A nyelv tömbjével létrehozott CreateInstance(Type, Int32[], Int32[]) rangok közül azonban nulla alapú tömböket is leadhat. Az ezzel a módszerrel létrehozott kétdimenziós, nulla alapú egész számtömböt például c#-típusra állíthatja int[,] .

A következőre érvényes:

CreateInstance(Type, Int32, Int32, Int32)

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

A megadott Array és a dimenzióhosszok háromdimenziós Type létrehozása nulla alapú indexeléssel.

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

Paraméterek

elementType: Type

Type A Array létrehozandók száma.

length1: Int32

A létrehozandó első dimenzió mérete Array .

length2: Int32

A létrehozandó második dimenzió mérete Array .

length3: Int32

A létrehozandó harmadik dimenzió Array mérete.

Válaszok

Array

Az egyes dimenziókhoz megadott hosszú, nulla alapú indexelést használó új háromdimenziós Array Type .

Kivételek

ArgumentNullException

elementType az null.

ArgumentException

elementType nem érvényes Type.

NotSupportedException

elementType nem támogatott. Például Void nem támogatott.

-vagy-

elementType egy nyitott általános típus.

ArgumentOutOfRangeException

length1 kisebb, mint nulla.

-vagy-

length2 kisebb, mint nulla.

-vagy-

length3 kisebb, mint nulla.

Példák

Az alábbi példakód bemutatja, hogyan hozhat létre és inicializálhat háromdimenziós Arrayobjektumokat.

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

Megjegyzések

A legtöbb osztálytól Array eltérően a nyilvános konstruktorok helyett a CreateInstance metódus biztosítja a késői kötésű hozzáférés engedélyezését.

A referencia típusú elemek inicializálása a következőre van inicializálva null: . Az érték típusú elemek nullára vannak inicializálva.

Ez a módszer egy O(n) művelet, ahol n az , length1és length2a .length3

Az F#-ban a Array3D.zeroCreate függvény használható helyette.

A következőre érvényes:

Visszajelzés

Hasznosnak találta ezt az oldalt?