Type.MakeArrayType Méthode

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Retourne un objet Type qui représente un tableau du type actuel.

Surcharges

MakeArrayType()	Retourne un objet Type qui représente un tableau unidimensionnel du type actuel, avec une limite inférieure de zéro.
MakeArrayType(Int32)	Retourne un objet Type qui représente un tableau du type actuel, avec le nombre spécifié de dimensions.

Exemples

L’exemple de code suivant crée des types de tableau ( refByRef en Visual Basic) et de pointeur pour la Test classe .

using namespace System;
using namespace System::Reflection;

public ref class Example
{
public:
   static void Main()
   {
      // Create a Type object that represents a one-dimensional
      // array of Example objects.
      Type^ t = Example::typeid->MakeArrayType();
      Console::WriteLine( L"\r\nArray of Example: {0}", t );
      
      // Create a Type object that represents a two-dimensional
      // array of Example objects.
      t = Example::typeid->MakeArrayType( 2 );
      Console::WriteLine( L"\r\nTwo-dimensional array of Example: {0}", t );
      
      // Demonstrate an exception when an invalid array rank is
      // specified.
      try
      {
         t = Example::typeid->MakeArrayType(  -1 );
      }
      catch ( Exception^ ex ) 
      {
         Console::WriteLine( L"\r\n{0}", ex );
      }
      
      // Create a Type object that represents a ByRef parameter
      // of type Example.
      t = Example::typeid->MakeByRefType();
      Console::WriteLine( L"\r\nByRef Example: {0}", t );
      
      // Get a Type object representing the Example class, a
      // MethodInfo representing the "Test" method, a ParameterInfo
      // representing the parameter of type Example, and finally
      // a Type object representing the type of this ByRef parameter.
      // Compare this Type object with the Type object created using
      // MakeByRefType.
      Type^ t2 = Example::typeid;
      MethodInfo^ mi = t2->GetMethod( L"Test" );
      ParameterInfo^ pi = mi->GetParameters()[ 0 ];
      Type^ pt = pi->ParameterType;
      Console::WriteLine( L"Are the ByRef types equal? {0}", (t == pt) );
      
      // Create a Type object that represents a pointer to an
      // Example object.
      t = Example::typeid->MakePointerType();
      Console::WriteLine( L"\r\nPointer to Example: {0}", t );
   }

   // A sample method with a ByRef parameter.
   //
   void Test( interior_ptr<Example^> /*e*/ )
   {
   }
};

int main()
{
   Example::Main();
}

/* This example produces output similar to the following:

Array of Example: Example[]

Two-dimensional array of Example: Example[,]

System.IndexOutOfRangeException: Index was outside the bounds of the array.
   at System.RuntimeType.MakeArrayType(Int32 rank) in c:\vbl\ndp\clr\src\BCL\System\RtType.cs:line 2999
   at Example.Main()

ByRef Example: Example&
Are the ByRef types equal? True

Pointer to Example: Example*

 */

using System;
using System.Reflection;

public class Example
{
    public static void Main()
    {
        // Create a Type object that represents a one-dimensional
        // array of Example objects.
        Type t = typeof(Example).MakeArrayType();
        Console.WriteLine("\r\nArray of Example: {0}", t);

        // Create a Type object that represents a two-dimensional
        // array of Example objects.
        t = typeof(Example).MakeArrayType(2);
        Console.WriteLine("\r\nTwo-dimensional array of Example: {0}", t);

        // Demonstrate an exception when an invalid array rank is
        // specified.
        try
        {
            t = typeof(Example).MakeArrayType(-1);
        }
        catch(Exception ex)
        {
            Console.WriteLine("\r\n{0}", ex);
        }

        // Create a Type object that represents a ByRef parameter
        // of type Example.
        t = typeof(Example).MakeByRefType();
        Console.WriteLine("\r\nByRef Example: {0}", t);

        // Get a Type object representing the Example class, a
        // MethodInfo representing the "Test" method, a ParameterInfo
        // representing the parameter of type Example, and finally
        // a Type object representing the type of this ByRef parameter.
        // Compare this Type object with the Type object created using
        // MakeByRefType.
        Type t2 = typeof(Example);
        MethodInfo mi = t2.GetMethod("Test");
        ParameterInfo pi = mi.GetParameters()[0];
        Type pt = pi.ParameterType;
        Console.WriteLine("Are the ByRef types equal? {0}", (t == pt));

        // Create a Type object that represents a pointer to an
        // Example object.
        t = typeof(Example).MakePointerType();
        Console.WriteLine("\r\nPointer to Example: {0}", t);
    }

    // A sample method with a ByRef parameter.
    //
    public void Test(ref Example e)
    {
    }
}

/* This example produces output similar to the following:

Array of Example: Example[]

Two-dimensional array of Example: Example[,]

System.IndexOutOfRangeException: Index was outside the bounds of the array.
   at System.RuntimeType.MakeArrayType(Int32 rank) in c:\vbl\ndp\clr\src\BCL\System\RtType.cs:line 2999
   at Example.Main()

ByRef Example: Example&
Are the ByRef types equal? True

Pointer to Example: Example*

 */

type Example() =
    // A sample method with a ByRef parameter.
    member _.Test(e: Example byref) = ()

do
    // Create a Type object that represents a one-dimensional
    // array of Example objects.
    let t = typeof<Example>.MakeArrayType()
    printfn $"\r\nArray of Example: {t}"

    // Create a Type object that represents a two-dimensional
    // array of Example objects.
    let t = typeof<Example>.MakeArrayType 2
    printfn $"\r\nTwo-dimensional array of Example: {t}"

    // Demonstrate an exception when an invalid array rank is
    // specified.
    try
        let t = typeof<Example>.MakeArrayType -1
        ()
    with ex ->
        printfn $"\r\n{ex}"

    // Create a Type object that represents a ByRef parameter
    // of type Example.
    let t = typeof<Example>.MakeByRefType()
    printfn $"\r\nByRef Example: {t}"

    // Get a Type object representing the Example class, a
    // MethodInfo representing the "Test" method, a ParameterInfo
    // representing the parameter of type Example, and finally
    // a Type object representing the type of this ByRef parameter.
    // Compare this Type object with the Type object created using
    // MakeByRefType.
    let t2 = typeof<Example>
    let mi = t2.GetMethod "Test"
    let pi = mi.GetParameters()[0]
    let pt = pi.ParameterType
    printfn $"Are the ByRef types equal? {t = pt}"

    // Create a Type object that represents a pointer to an
    // Example object.
    let t = typeof<Example>.MakePointerType()
    printfn $"\r\nPointer to Example: {t}"

(* This example produces output similar to the following:

Array of Example: Example[]

Two-dimensional array of Example: Example[,]

System.IndexOutOfRangeException: Index was outside the bounds of the array.
   at System.RuntimeType.MakeArrayType(Int32 rank) in c:\vbl\ndp\clr\src\BCL\System\RtType.cs:line 2999
   at Example.Main()

ByRef Example: Example&
Are the ByRef types equal? True

Pointer to Example: Example*
 *)

Imports System.Reflection

Public Class Example
    Public Shared Sub Main()
        ' Create a Type object that represents a one-dimensional
        ' array of Example objects.
        Dim t As Type = GetType(Example).MakeArrayType()
        Console.WriteLine(vbCrLf & "Array of Example: " & t.ToString())

        ' Create a Type object that represents a two-dimensional
        ' array of Example objects.
        t = GetType(Example).MakeArrayType(2)
        Console.WriteLine(vbCrLf & "Two-dimensional array of Example: " & t.ToString())

        ' Demonstrate an exception when an invalid array rank is
        ' specified.
        Try
            t = GetType(Example).MakeArrayType(-1)
        Catch ex As Exception
            Console.WriteLine(vbCrLf & ex.ToString())
        End Try

        ' Create a Type object that represents a ByRef parameter
        ' of type Example.
        t = GetType(Example).MakeByRefType()
        Console.WriteLine(vbCrLf & "ByRef Example: " & t.ToString())

        ' Get a Type object representing the Example class, a
        ' MethodInfo representing the "Test" method, a ParameterInfo
        ' representing the parameter of type Example, and finally
        ' a Type object representing the type of this ByRef parameter.
        ' Compare this Type object with the Type object created using
        ' MakeByRefType.
        Dim t2 As Type = GetType(Example)
        Dim mi As MethodInfo = t2.GetMethod("Test")
        Dim pi As ParameterInfo = mi.GetParameters()(0)
        Dim pt As Type = pi.ParameterType
        Console.WriteLine("Are the ByRef types equal? " & (t Is pt))

        ' Create a Type object that represents a pointer to an
        ' Example object.
        t = GetType(Example).MakePointerType()
        Console.WriteLine(vbCrLf & "Pointer to Example: " & t.ToString())
    End Sub

    ' A sample method with a ByRef parameter.
    '
    Public Sub Test(ByRef e As Example)
    End Sub
End Class

' This example produces output similar to the following:
'
'Array of Example: Example[]
'
'Two-dimensional array of Example: Example[,]
'
'System.IndexOutOfRangeException: Index was outside the bounds of the array.
'   at System.RuntimeType.MakeArrayType(Int32 rank) in c:\vbl\ndp\clr\src\BCL\System\RtType.cs:line 2999
'   at Example.Main()
'
'ByRef Example: Example&
'Are the ByRef types equal? True
'
'Pointer to Example: Example*

MakeArrayType()

Source:

Type.cs

Retourne un objet Type qui représente un tableau unidimensionnel du type actuel, avec une limite inférieure de zéro.

public:
 virtual Type ^ MakeArrayType();

public virtual Type MakeArrayType ();

abstract member MakeArrayType : unit -> Type
override this.MakeArrayType : unit -> Type

Public Overridable Function MakeArrayType () As Type

Retours

Type

Objet Type qui représente un tableau unidimensionnel du type actuel, avec une limite inférieure de zéro.

Exceptions

NotSupportedException

La méthode appelée n’est pas prise en charge dans la classe de base. Les classes dérivées doivent fournir une implémentation.

TypeLoadException

Le type actuel est TypedReference.

- ou -

Le type actuel est un type ByRef. Autrement dit, IsByRef retourne true.

Remarques

La MakeArrayType méthode permet de générer des types de tableaux dont les types d’éléments sont calculés au moment de l’exécution.

Note Le Common Language Runtime fait une distinction entre les vecteurs (c’est-à-dire les tableaux unidimensionnels qui sont toujours de base zéro) et les tableaux multidimensionnels. Un vecteur, qui n’a toujours qu’une seule dimension, n’est pas identique à un tableau multidimensionnel qui n’a qu’une seule dimension. Cette surcharge de méthode ne peut être utilisée que pour créer des types vectoriels, et c’est la seule façon de créer un type de vecteur. Utilisez la surcharge de MakeArrayType(Int32) méthode pour créer des types de tableaux multidimensionnels.

Voir aussi

• MakeByRefType()
• MakePointerType()

MakeArrayType(Int32)

Source:

Type.cs

Retourne un objet Type qui représente un tableau du type actuel, avec le nombre spécifié de dimensions.

public:
 virtual Type ^ MakeArrayType(int rank);

public virtual Type MakeArrayType (int rank);

abstract member MakeArrayType : int -> Type
override this.MakeArrayType : int -> Type

Public Overridable Function MakeArrayType (rank As Integer) As Type

Paramètres

rank

Int32

Nombre de dimensions pour le tableau. Ce nombre doit être inférieur ou égal à 32.

Retours

Type

Objet qui représente un tableau du type actuel, avec le nombre spécifié de dimensions.

Exceptions

IndexOutOfRangeException

rank n'est pas valide. Par exemple, 0 ou un nombre négatif.

NotSupportedException

La méthode appelée n’est pas prise en charge dans la classe de base.

TypeLoadException

Le type actuel est TypedReference.

- ou -

Le type actuel est un type ByRef. Autrement dit, IsByRef retourne true.

- ou -

rank est supérieur à 32.

Remarques

La MakeArrayType méthode permet de générer des types de tableaux dont les types d’éléments sont calculés au moment de l’exécution.

Notes

Le Common Language Runtime fait une distinction entre les vecteurs (c’est-à-dire les tableaux unidimensionnels qui sont toujours de base zéro) et les tableaux multidimensionnels. Un vecteur, qui n’a toujours qu’une seule dimension, n’est pas identique à un tableau multidimensionnel qui n’a qu’une seule dimension. Vous ne pouvez pas utiliser cette surcharge de méthode pour créer un type de vecteur ; si rank a la valeur 1, cette surcharge de méthode retourne un type de tableau multidimensionnel qui a une dimension. Utilisez la surcharge de MakeArrayType() méthode pour créer des types de vecteurs.

Voir aussi

• MakeByRefType()
• MakePointerType()