GenericTypeParameterBuilder.MakeByRefType 메서드

정의

참조 매개 변수로 전달될 때 현재 제네릭 형식 매개 변수를 나타내는 Type 개체를 반환합니다.

public:
 override Type ^ MakeByRefType();
public override Type MakeByRefType ();
override this.MakeByRefType : unit -> Type
Public Overrides Function MakeByRefType () As Type

반환

Type

참조 매개 변수로 전달될 때 현재 제네릭 형식 매개 변수를 나타내는 Type 개체입니다.

예제

다음 코드 예제에서는 동적 모듈, 하나의 형식 매개 변수T로 명명된 Sample 추상 제네릭 형식 및 명명TestMethod된 추상 메서드를 만듭니다. TestMethod는 형식의 ref 매개 변수(ByRefVisual Basic), 형식T``T에 대한 포인터 및 배열T을 사용합니다. 이 메서드는 2차원 배열을 반환합니다 T. 코드 예제에서는 동적 모듈을 디스크에 저장하므로 MSIL 디스어셈블러(Ildasm.exe)를 사용하여 검사할 수 있습니다.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;

int main()
{
    // Define a dynamic assembly to contain the sample type. The
    // assembly will not be run, but only saved to disk, so
    // AssemblyBuilderAccess.Save is specified.
    //
    AppDomain^ appDomain = AppDomain::CurrentDomain;
    AssemblyName^ assemblyName = gcnew
        AssemblyName("MakeXxxGenericTypeParameterExample");
    AssemblyBuilder^ assemblyBuilder = appDomain->DefineDynamicAssembly
        (assemblyName, AssemblyBuilderAccess::Save);

    // An assembly is made up of executable modules. For a single
    // module assembly, the module name and file name are the
    // same as the assembly name.
    ModuleBuilder^ moduleBuilder = assemblyBuilder->DefineDynamicModule
        (assemblyName->Name, assemblyName->Name + ".dll");

    // Define the sample type.
    TypeBuilder^ typeBuilder = moduleBuilder->DefineType("Sample",
        TypeAttributes::Public | TypeAttributes::Abstract);

    // Make the sample type a generic type, by defining a type
    // parameter T. All type parameters are defined at the same
    // time, by passing an array containing the type parameter
    // names. 
    array<String^>^ typeParamNames = {"T"};
    array<GenericTypeParameterBuilder^>^ typeParams =
        typeBuilder->DefineGenericParameters(typeParamNames);

    // Define a method that takes a ByRef argument of type T, a
    // pointer to type T, and one-dimensional array of type T.
    // The method returns a two-dimensional array of type T.
    //
    // To create this method, you need Type objects that repre-
    // sent the parameter types and the return type. Use the
    // MakeByRefType, MakePointerType, and MakeArrayType methods
    // to create the Type objects, using the generic type para-
    // meter T.
    //
    Type^ byRefType = typeParams[0]->MakeByRefType();
    Type^ pointerType = typeParams[0]->MakePointerType();
    Type^ arrayType = typeParams[0]->MakeArrayType();
    Type^ twoDimArrayType = typeParams[0]->MakeArrayType(2);

    // Create the array of parameter types.
    array<Type^>^ parameterTypes = {byRefType, pointerType, arrayType};

    // Define the abstract Test method. After you have compiled
    // and run this example code, you can use ildasm.exe to open
    // MakeXxxGenericTypeParameterExample.dll, examine the Sample
    // type, and verify the parameter types and return type of
    // the TestMethod method.
    //
    MethodBuilder^ methodBuilder = typeBuilder->DefineMethod("TestMethod",
        MethodAttributes::Abstract | MethodAttributes::Virtual 
        | MethodAttributes::Public, twoDimArrayType, parameterTypes);

    // Create the type and save the assembly. For a single-file 
    // assembly, there is only one module to store the manifest 
    // information in.
    //
    typeBuilder->CreateType();
    assemblyBuilder->Save(assemblyName->Name + ".dll");
};
using System;
using System.Reflection;
using System.Reflection.Emit;
using Microsoft.VisualBasic;

public class Example
{
    public static void Main()
    {
        // Define a dynamic assembly to contain the sample type. The
        // assembly will not be run, but only saved to disk, so
        // AssemblyBuilderAccess.Save is specified.
        //
        AppDomain myDomain = AppDomain.CurrentDomain;
        AssemblyName myAsmName = new
            AssemblyName("MakeXxxGenericTypeParameterExample");
        AssemblyBuilder myAssembly = myDomain.DefineDynamicAssembly(
            myAsmName, AssemblyBuilderAccess.Save);

        // An assembly is made up of executable modules. For a single-
        // module assembly, the module name and file name are the same
        // as the assembly name.
        //
        ModuleBuilder myModule = myAssembly.DefineDynamicModule(
            myAsmName.Name, myAsmName.Name + ".dll");

        // Define the sample type.
        TypeBuilder myType = myModule.DefineType("Sample",
            TypeAttributes.Public | TypeAttributes.Abstract);

        // Make the sample type a generic type, by defining a type
        // parameter T. All type parameters are defined at the same
        // time, by passing an array containing the type parameter
        // names.
        string[] typeParamNames = {"T"};
        GenericTypeParameterBuilder[] typeParams =
            myType.DefineGenericParameters(typeParamNames);

        // Define a method that takes a ByRef argument of type T, a
        // pointer to type T, and one-dimensional array of type T. The
        // method returns a two-dimensional array of type T.
        //
        // To create this method, you need Type objects that represent the
        // parameter types and the return type. Use the MakeByRefType,
        // MakePointerType, and MakeArrayType methods to create the Type
        // objects, using the generic type parameter T.
        //
        Type byRefType = typeParams[0].MakeByRefType();
        Type pointerType = typeParams[0].MakePointerType();
        Type arrayType = typeParams[0].MakeArrayType();
        Type twoDimArrayType = typeParams[0].MakeArrayType(2);

        // Create the array of parameter types.
        Type[] parameterTypes = {byRefType, pointerType, arrayType};

        // Define the abstract Test method. After you have compiled
        // and run this example code, you can use ildasm.exe to open
        // MakeXxxGenericTypeParameterExample.dll, examine the Sample
        // type, and verify the parameter types and return type of
        // the TestMethod method.
        //
        MethodBuilder myMethodBuilder = myType.DefineMethod(
            "TestMethod",
            MethodAttributes.Abstract | MethodAttributes.Virtual
            | MethodAttributes.Public,
            twoDimArrayType,
            parameterTypes);

        // Create the type and save the assembly. For a single-file
        // assembly, there is only one module to store the manifest
        // information in.
        //
        myType.CreateType();
        myAssembly.Save(myAsmName.Name + ".dll");
    }
}
Imports System.Reflection
Imports System.Reflection.Emit

Public Class Example
    Public Shared Sub Main()
        ' Define a dynamic assembly to contain the sample type. The
        ' assembly will not be run, but only saved to disk, so
        ' AssemblyBuilderAccess.Save is specified.
        '
        Dim myDomain As AppDomain = AppDomain.CurrentDomain
        Dim myAsmName As New AssemblyName("MakeXxxGenericTypeParameterExample")
        Dim myAssembly As AssemblyBuilder = myDomain.DefineDynamicAssembly( _
            myAsmName, _
            AssemblyBuilderAccess.Save)

        ' An assembly is made up of executable modules. For a single-
        ' module assembly, the module name and file name are the same 
        ' as the assembly name. 
        '
        Dim myModule As ModuleBuilder = myAssembly.DefineDynamicModule( _
            myAsmName.Name, _
            myAsmName.Name & ".dll")

        ' Define the sample type.
        Dim myType As TypeBuilder = myModule.DefineType( _
            "Sample", _
            TypeAttributes.Public Or TypeAttributes.Abstract)

        ' Make the sample type a generic type, by defining a type
        ' parameter T. All type parameters are defined at the same
        ' time, by passing an array containing the type parameter
        ' names. 
        Dim typeParamNames() As String = {"T"}
        Dim typeParams() As GenericTypeParameterBuilder = _
            myType.DefineGenericParameters(typeParamNames)

        ' Define a method that takes a ByRef argument of type T, a
        ' pointer to type T, and one-dimensional array of type T. The
        ' method returns a two-dimensional array of type T.
        '
        ' To create this method, you need Type objects that represent the
        ' parameter types and the return type. Use the MakeByRefType, 
        ' MakePointerType, and MakeArrayType methods to create the Type
        ' objects, using the generic type parameter T.
        '
        Dim byRefType As Type = typeParams(0).MakeByRefType
        Dim pointerType As Type = typeParams(0).MakePointerType
        Dim arrayType As Type = typeParams(0).MakeArrayType
        Dim twoDimArrayType As Type = typeParams(0).MakeArrayType(2)

        ' Create the array of parameter types.
        Dim parameterTypes() As Type = _
            {byRefType, pointerType, arrayType}

        ' Define the abstract Test method. After you have compiled
        ' and run this example code, you can use ildasm.exe to open
        ' MakeXxxGenericTypeParameterExample.dll, examine the Sample
        ' type, and verify the parameter types and return type of
        ' the TestMethod method.
        '
        Dim myMethodBuilder As MethodBuilder = myType.DefineMethod( _
            "TestMethod", _
            MethodAttributes.Abstract Or MethodAttributes.Virtual _
                Or MethodAttributes.Public, _
            twoDimArrayType, _
            parameterTypes)

        ' Create the type and save the assembly. For a single-file 
        ' assembly, there is only one module to store the manifest 
        ' information in.
        '
        myType.CreateType()
        myAssembly.Save(myAsmName.Name & ".dll")

    End Sub
End Class

설명

이 메서드는 MakeByRefType 매개 변수 목록에 대한 형식(ByRefVisual Basic)을 생성하는 ref 방법을 제공합니다.

적용 대상

추가 정보