Type.MakePointerType Méthode

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assembly:: mscorlib.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Retourne un objet Type qui représente un pointeur vers le type actuel.

public:
 abstract Type ^ MakePointerType();

public:
 virtual Type ^ MakePointerType();

public abstract Type MakePointerType ();

public virtual Type MakePointerType ();

abstract member MakePointerType : unit -> Type

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

Public MustOverride Function MakePointerType () As Type

Public Overridable Function MakePointerType () As Type

Retours

Type

Objet Type qui représente un pointeur vers le type actuel.

Exceptions

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.

Exemples

l’exemple de code suivant crée un tableau, ref ( ByRef en Visual Basic) et des types 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*

 */

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*

Remarques

La MakePointerType méthode fournit un moyen de générer des types pointeur pour les listes de paramètres.

À l’aide de la syntaxe du langage MSIL (Microsoft Intermediate Language), si l' Type objet actuel représente Int32 , cette méthode retourne un Type objet représentant Int32* .

S’applique à

Partage via