Type.MakeArrayType 메서드

정의

네임스페이스:

System

어셈블리:

System.Runtime.dll

현재 형식의 배열을 나타내는 Type 개체를 반환합니다.

오버로드

MakeArrayType()	하한이 0인 현재 형식의 1차원 배열을 나타내는 Type 개체를 반환합니다.
MakeArrayType(Int32)	지정된 차수의 현재 형식 배열을 나타내는 Type 개체를 반환합니다.

예제

다음 코드 예제에서는 배열( refByRef Visual Basic의 경우) 및 클래스에 대한 포인터 형식을 Test 만듭니다.

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

하한이 0인 현재 형식의 1차원 배열을 나타내는 Type 개체를 반환합니다.

public:
 virtual Type ^ MakeArrayType();

public virtual Type MakeArrayType ();

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

Public Overridable Function MakeArrayType () As Type

반환

Type

하한이 0인 현재 형식의 1차원 배열을 나타내는 Type 개체입니다.

예외

NotSupportedException

호출된 메서드가 기본 클래스에서 지원되지 않습니다. 파생 클래스에서 구현을 제공해야 합니다.

TypeLoadException

현재 형식이 TypedReference입니다.

또는

현재 형식이 ByRef 형식입니다. 즉, IsByRef이 true를 반환합니다.

설명

메서드는 MakeArrayType 런타임에 요소 형식이 계산되는 배열 형식을 생성하는 방법을 제공합니다.

참고 공용 언어 런타임은 벡터(즉, 항상 0부터 시작하는 1차원 배열)와 다차원 배열을 구분합니다. 항상 하나의 차원만 있는 벡터는 하나의 차원만 있는 다차원 배열과 동일하지 않습니다. 이 메서드 오버로드는 벡터 형식을 만드는 데만 사용할 수 있으며 벡터 형식을 만드는 유일한 방법입니다. 메서드 오버로드를 MakeArrayType(Int32) 사용하여 다차원 배열 형식을 만듭니다.

추가 정보

• MakeByRefType()
• MakePointerType()

MakeArrayType(Int32)

Source:

Type.cs

지정된 차수의 현재 형식 배열을 나타내는 Type 개체를 반환합니다.

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

매개 변수

rank

Int32

배열의 차수입니다. 이 수는 32보다 작거나 같아야 합니다.

반환

Type

지정된 차수의 현재 형식 배열을 나타내는 개체입니다.

예외

IndexOutOfRangeException

rank이 잘못되었습니다. 예를 들면, 0 또는 음수입니다.

NotSupportedException

호출된 메서드가 기본 클래스에서 지원되지 않습니다.

TypeLoadException

현재 형식이 TypedReference입니다.

또는

현재 형식이 ByRef 형식입니다. 즉, IsByRef 이 true를 반환합니다.

또는

rank이(가) 32보다 큽니다.

설명

메서드는 MakeArrayType 런타임에 요소 형식이 계산되는 배열 형식을 생성하는 방법을 제공합니다.

참고

공용 언어 런타임은 벡터(즉, 항상 0부터 시작하는 1차원 배열)와 다차원 배열을 구분합니다. 항상 하나의 차원만 있는 벡터는 하나의 차원만 있는 다차원 배열과 동일하지 않습니다. 이 메서드 오버로드를 사용하여 벡터 형식을 만들 수 없습니다. 가 1이면 rank 이 메서드 오버로드는 1차원을 갖는 다차원 배열 형식을 반환합니다. 메서드 오버로드를 MakeArrayType() 사용하여 벡터 형식을 만듭니다.

추가 정보

• MakeByRefType()
• MakePointerType()