TypeBuilder Kelas

Definisi

Ruang nama:

System.Reflection.Emit

Rakitan:

netstandard.dll, System.Reflection.Emit.dll

Sumber:

TypeBuilder.cs

Menentukan dan membuat instans kelas baru selama run time.

public ref class TypeBuilder abstract : System::Reflection::TypeInfo

public abstract class TypeBuilder : System.Reflection.TypeInfo

type TypeBuilder = class
    inherit TypeInfo

Public MustInherit Class TypeBuilder
Inherits TypeInfo

Warisan

Object

MemberInfo

Type

TypeInfo

TypeBuilder

Contoh

Contoh kode berikut menunjukkan cara menentukan dan menggunakan rakitan dinamis. Contoh rakitan berisi satu jenis, MyDynamicType, yang memiliki bidang privat, properti yang mendapatkan dan mengatur bidang privat, konstruktor yang menginisialisasi bidang privat, dan metode yang mengalikan angka yang disediakan pengguna dengan nilai bidang privat dan mengembalikan hasilnya.

using System;
using System.Reflection;
using System.Reflection.Emit;

class DemoAssemblyBuilder
{
    public static void Main()
    {
        // This code creates an assembly that contains one type,
        // named "MyDynamicType", that has a private field, a property
        // that gets and sets the private field, constructors that
        // initialize the private field, and a method that multiplies
        // a user-supplied number by the private field value and returns
        // the result. In C# the type might look like this:
        /*
        public class MyDynamicType
        {
            private int m_number;

            public MyDynamicType() : this(42) {}
            public MyDynamicType(int initNumber)
            {
                m_number = initNumber;
            }

            public int Number
            {
                get { return m_number; }
                set { m_number = value; }
            }

            public int MyMethod(int multiplier)
            {
                return m_number * multiplier;
            }
        }
        */

        var aName = new AssemblyName("DynamicAssemblyExample");
        AssemblyBuilder ab =
            AssemblyBuilder.DefineDynamicAssembly(
                aName,
                AssemblyBuilderAccess.Run);

        // The module name is usually the same as the assembly name.
        ModuleBuilder mb = ab.DefineDynamicModule(aName.Name ?? "DynamicAssemblyExample");

        TypeBuilder tb = mb.DefineType(
            "MyDynamicType",
             TypeAttributes.Public);

        // Add a private field of type int (Int32).
        FieldBuilder fbNumber = tb.DefineField(
            "m_number",
            typeof(int),
            FieldAttributes.Private);

        // Define a constructor that takes an integer argument and
        // stores it in the private field.
        Type[] parameterTypes = { typeof(int) };
        ConstructorBuilder ctor1 = tb.DefineConstructor(
            MethodAttributes.Public,
            CallingConventions.Standard,
            parameterTypes);

        ILGenerator ctor1IL = ctor1.GetILGenerator();
        // For a constructor, argument zero is a reference to the new
        // instance. Push it on the stack before calling the base
        // class constructor. Specify the default constructor of the
        // base class (System.Object) by passing an empty array of
        // types (Type.EmptyTypes) to GetConstructor.
        ctor1IL.Emit(OpCodes.Ldarg_0);
        ConstructorInfo? ci = typeof(object).GetConstructor(Type.EmptyTypes);
        ctor1IL.Emit(OpCodes.Call, ci!);
        // Push the instance on the stack before pushing the argument
        // that is to be assigned to the private field m_number.
        ctor1IL.Emit(OpCodes.Ldarg_0);
        ctor1IL.Emit(OpCodes.Ldarg_1);
        ctor1IL.Emit(OpCodes.Stfld, fbNumber);
        ctor1IL.Emit(OpCodes.Ret);

        // Define a default constructor that supplies a default value
        // for the private field. For parameter types, pass the empty
        // array of types or pass null.
        ConstructorBuilder ctor0 = tb.DefineConstructor(
            MethodAttributes.Public,
            CallingConventions.Standard,
            Type.EmptyTypes);

        ILGenerator ctor0IL = ctor0.GetILGenerator();
        // For a constructor, argument zero is a reference to the new
        // instance. Push it on the stack before pushing the default
        // value on the stack, then call constructor ctor1.
        ctor0IL.Emit(OpCodes.Ldarg_0);
        ctor0IL.Emit(OpCodes.Ldc_I4_S, 42);
        ctor0IL.Emit(OpCodes.Call, ctor1);
        ctor0IL.Emit(OpCodes.Ret);

        // Define a property named Number that gets and sets the private
        // field.
        //
        // The last argument of DefineProperty is null, because the
        // property has no parameters. (If you don't specify null, you must
        // specify an array of Type objects. For a parameterless property,
        // use the built-in array with no elements: Type.EmptyTypes)
        PropertyBuilder pbNumber = tb.DefineProperty(
            "Number",
            PropertyAttributes.HasDefault,
            typeof(int),
            null);

        // The property "set" and property "get" methods require a special
        // set of attributes.
        MethodAttributes getSetAttr = MethodAttributes.Public |
            MethodAttributes.SpecialName | MethodAttributes.HideBySig;

        // Define the "get" accessor method for Number. The method returns
        // an integer and has no arguments. (Note that null could be
        // used instead of Types.EmptyTypes)
        MethodBuilder mbNumberGetAccessor = tb.DefineMethod(
            "get_Number",
            getSetAttr,
            typeof(int),
            Type.EmptyTypes);

        ILGenerator numberGetIL = mbNumberGetAccessor.GetILGenerator();
        // For an instance property, argument zero is the instance. Load the
        // instance, then load the private field and return, leaving the
        // field value on the stack.
        numberGetIL.Emit(OpCodes.Ldarg_0);
        numberGetIL.Emit(OpCodes.Ldfld, fbNumber);
        numberGetIL.Emit(OpCodes.Ret);

        // Define the "set" accessor method for Number, which has no return
        // type and takes one argument of type int (Int32).
        MethodBuilder mbNumberSetAccessor = tb.DefineMethod(
            "set_Number",
            getSetAttr,
            null,
            new Type[] { typeof(int) });

        ILGenerator numberSetIL = mbNumberSetAccessor.GetILGenerator();
        // Load the instance and then the numeric argument, then store the
        // argument in the field.
        numberSetIL.Emit(OpCodes.Ldarg_0);
        numberSetIL.Emit(OpCodes.Ldarg_1);
        numberSetIL.Emit(OpCodes.Stfld, fbNumber);
        numberSetIL.Emit(OpCodes.Ret);

        // Last, map the "get" and "set" accessor methods to the
        // PropertyBuilder. The property is now complete.
        pbNumber.SetGetMethod(mbNumberGetAccessor);
        pbNumber.SetSetMethod(mbNumberSetAccessor);

        // Define a method that accepts an integer argument and returns
        // the product of that integer and the private field m_number. This
        // time, the array of parameter types is created on the fly.
        MethodBuilder meth = tb.DefineMethod(
            "MyMethod",
            MethodAttributes.Public,
            typeof(int),
            new Type[] { typeof(int) });

        ILGenerator methIL = meth.GetILGenerator();
        // To retrieve the private instance field, load the instance it
        // belongs to (argument zero). After loading the field, load the
        // argument one and then multiply. Return from the method with
        // the return value (the product of the two numbers) on the
        // execution stack.
        methIL.Emit(OpCodes.Ldarg_0);
        methIL.Emit(OpCodes.Ldfld, fbNumber);
        methIL.Emit(OpCodes.Ldarg_1);
        methIL.Emit(OpCodes.Mul);
        methIL.Emit(OpCodes.Ret);

        // Finish the type.
        Type? t = tb.CreateType();

        // Because AssemblyBuilderAccess includes Run, the code can be
        // executed immediately. Start by getting reflection objects for
        // the method and the property.
        MethodInfo? mi = t?.GetMethod("MyMethod");
        PropertyInfo? pi = t?.GetProperty("Number");

        // Create an instance of MyDynamicType using the default
        // constructor.
        object? o1 = null;
        if (t is not null)
            o1 = Activator.CreateInstance(t);

        // Display the value of the property, then change it to 127 and
        // display it again. Use null to indicate that the property
        // has no index.
        Console.WriteLine("o1.Number: {0}", pi?.GetValue(o1, null));
        pi?.SetValue(o1, 127, null);
        Console.WriteLine("o1.Number: {0}", pi?.GetValue(o1, null));

        // Call MyMethod, passing 22, and display the return value, 22
        // times 127. Arguments must be passed as an array, even when
        // there is only one.
        object[] arguments = { 22 };
        Console.WriteLine("o1.MyMethod(22): {0}",
            mi?.Invoke(o1, arguments));

        // Create an instance of MyDynamicType using the constructor
        // that specifies m_Number. The constructor is identified by
        // matching the types in the argument array. In this case,
        // the argument array is created on the fly. Display the
        // property value.
        object? o2 = null;
        if (t is not null)
            o2 = Activator.CreateInstance(t, new object[] { 5280 });
        Console.WriteLine("o2.Number: {0}", pi?.GetValue(o2, null));
    }
}

/* This code produces the following output:

o1.Number: 42
o1.Number: 127
o1.MyMethod(22): 2794
o2.Number: 5280
 */

Imports System.Reflection
Imports System.Reflection.Emit

Class DemoAssemblyBuilder

    Public Shared Sub Main()

        ' This code creates an assembly that contains one type,
        ' named "MyDynamicType", that has a private field, a property
        ' that gets and sets the private field, constructors that
        ' initialize the private field, and a method that multiplies
        ' a user-supplied number by the private field value and returns
        ' the result. The code might look like this in Visual Basic:
        '
        'Public Class MyDynamicType
        '    Private m_number As Integer
        '
        '    Public Sub New()
        '        Me.New(42)
        '    End Sub
        '
        '    Public Sub New(ByVal initNumber As Integer)
        '        m_number = initNumber
        '    End Sub
        '
        '    Public Property Number As Integer
        '        Get
        '            Return m_number
        '        End Get
        '        Set
        '            m_Number = Value
        '        End Set
        '    End Property
        '
        '    Public Function MyMethod(ByVal multiplier As Integer) As Integer
        '        Return m_Number * multiplier
        '    End Function
        'End Class
      
        Dim aName As New AssemblyName("DynamicAssemblyExample")
        Dim ab As AssemblyBuilder = _
            AssemblyBuilder.DefineDynamicAssembly( _
                aName, _
                AssemblyBuilderAccess.Run)

        ' The module name is usually the same as the assembly name.
        Dim mb As ModuleBuilder = ab.DefineDynamicModule( _
            aName.Name)
      
        Dim tb As TypeBuilder = _
            mb.DefineType("MyDynamicType", TypeAttributes.Public)

        ' Add a private field of type Integer (Int32).
        Dim fbNumber As FieldBuilder = tb.DefineField( _
            "m_number", _
            GetType(Integer), _
            FieldAttributes.Private)

        ' Define a constructor that takes an integer argument and 
        ' stores it in the private field. 
        Dim parameterTypes() As Type = { GetType(Integer) }
        Dim ctor1 As ConstructorBuilder = _
            tb.DefineConstructor( _
                MethodAttributes.Public, _
                CallingConventions.Standard, _
                parameterTypes)

        Dim ctor1IL As ILGenerator = ctor1.GetILGenerator()
        ' For a constructor, argument zero is a reference to the new
        ' instance. Push it on the stack before calling the base
        ' class constructor. Specify the default constructor of the 
        ' base class (System.Object) by passing an empty array of 
        ' types (Type.EmptyTypes) to GetConstructor.
        ctor1IL.Emit(OpCodes.Ldarg_0)
        ctor1IL.Emit(OpCodes.Call, _
            GetType(Object).GetConstructor(Type.EmptyTypes))
        ' Push the instance on the stack before pushing the argument
        ' that is to be assigned to the private field m_number.
        ctor1IL.Emit(OpCodes.Ldarg_0)
        ctor1IL.Emit(OpCodes.Ldarg_1)
        ctor1IL.Emit(OpCodes.Stfld, fbNumber)
        ctor1IL.Emit(OpCodes.Ret)

        ' Define a default constructor that supplies a default value
        ' for the private field. For parameter types, pass the empty
        ' array of types or pass Nothing.
        Dim ctor0 As ConstructorBuilder = tb.DefineConstructor( _
            MethodAttributes.Public, _
            CallingConventions.Standard, _
            Type.EmptyTypes)

        Dim ctor0IL As ILGenerator = ctor0.GetILGenerator()
        ' For a constructor, argument zero is a reference to the new
        ' instance. Push it on the stack before pushing the default
        ' value on the stack, then call constructor ctor1.
        ctor0IL.Emit(OpCodes.Ldarg_0)
        ctor0IL.Emit(OpCodes.Ldc_I4_S, 42)
        ctor0IL.Emit(OpCodes.Call, ctor1)
        ctor0IL.Emit(OpCodes.Ret)

        ' Define a property named Number that gets and sets the private 
        ' field.
        '
        ' The last argument of DefineProperty is Nothing, because the
        ' property has no parameters. (If you don't specify Nothing, you must
        ' specify an array of Type objects. For a parameterless property,
        ' use the built-in array with no elements: Type.EmptyTypes)
        Dim pbNumber As PropertyBuilder = tb.DefineProperty( _
            "Number", _
            PropertyAttributes.HasDefault, _
            GetType(Integer), _
            Nothing)
      
        ' The property Set and property Get methods require a special
        ' set of attributes.
        Dim getSetAttr As MethodAttributes = _
            MethodAttributes.Public Or MethodAttributes.SpecialName _
                Or MethodAttributes.HideBySig

        ' Define the "get" accessor method for Number. The method returns
        ' an integer and has no arguments. (Note that Nothing could be 
        ' used instead of Types.EmptyTypes)
        Dim mbNumberGetAccessor As MethodBuilder = tb.DefineMethod( _
            "get_Number", _
            getSetAttr, _
            GetType(Integer), _
            Type.EmptyTypes)
      
        Dim numberGetIL As ILGenerator = mbNumberGetAccessor.GetILGenerator()
        ' For an instance property, argument zero is the instance. Load the 
        ' instance, then load the private field and return, leaving the
        ' field value on the stack.
        numberGetIL.Emit(OpCodes.Ldarg_0)
        numberGetIL.Emit(OpCodes.Ldfld, fbNumber)
        numberGetIL.Emit(OpCodes.Ret)
        
        ' Define the "set" accessor method for Number, which has no return
        ' type and takes one argument of type Integer (Int32).
        Dim mbNumberSetAccessor As MethodBuilder = _
            tb.DefineMethod( _
                "set_Number", _
                getSetAttr, _
                Nothing, _
                New Type() { GetType(Integer) })
      
        Dim numberSetIL As ILGenerator = mbNumberSetAccessor.GetILGenerator()
        ' Load the instance and then the numeric argument, then store the
        ' argument in the field.
        numberSetIL.Emit(OpCodes.Ldarg_0)
        numberSetIL.Emit(OpCodes.Ldarg_1)
        numberSetIL.Emit(OpCodes.Stfld, fbNumber)
        numberSetIL.Emit(OpCodes.Ret)
      
        ' Last, map the "get" and "set" accessor methods to the 
        ' PropertyBuilder. The property is now complete. 
        pbNumber.SetGetMethod(mbNumberGetAccessor)
        pbNumber.SetSetMethod(mbNumberSetAccessor)

        ' Define a method that accepts an integer argument and returns
        ' the product of that integer and the private field m_number. This
        ' time, the array of parameter types is created on the fly.
        Dim meth As MethodBuilder = tb.DefineMethod( _
            "MyMethod", _
            MethodAttributes.Public, _
            GetType(Integer), _
            New Type() { GetType(Integer) })

        Dim methIL As ILGenerator = meth.GetILGenerator()
        ' To retrieve the private instance field, load the instance it
        ' belongs to (argument zero). After loading the field, load the 
        ' argument one and then multiply. Return from the method with 
        ' the return value (the product of the two numbers) on the 
        ' execution stack.
        methIL.Emit(OpCodes.Ldarg_0)
        methIL.Emit(OpCodes.Ldfld, fbNumber)
        methIL.Emit(OpCodes.Ldarg_1)
        methIL.Emit(OpCodes.Mul)
        methIL.Emit(OpCodes.Ret)

        ' Finish the type.
        Dim t As Type = tb.CreateType()

        ' Because AssemblyBuilderAccess includes Run, the code can be
        ' executed immediately. Start by getting reflection objects for
        ' the method and the property.
        Dim mi As MethodInfo = t.GetMethod("MyMethod")
        Dim pi As PropertyInfo = t.GetProperty("Number")
  
        ' Create an instance of MyDynamicType using the default 
        ' constructor. 
        Dim o1 As Object = Activator.CreateInstance(t)

        ' Display the value of the property, then change it to 127 and 
        ' display it again. Use Nothing to indicate that the property
        ' has no index.
        Console.WriteLine("o1.Number: {0}", pi.GetValue(o1, Nothing))
        pi.SetValue(o1, 127, Nothing)
        Console.WriteLine("o1.Number: {0}", pi.GetValue(o1, Nothing))

        ' Call MyMethod, passing 22, and display the return value, 22
        ' times 127. Arguments must be passed as an array, even when
        ' there is only one.
        Dim arguments() As Object = { 22 }
        Console.WriteLine("o1.MyMethod(22): {0}", _
            mi.Invoke(o1, arguments))

        ' Create an instance of MyDynamicType using the constructor
        ' that specifies m_Number. The constructor is identified by
        ' matching the types in the argument array. In this case, 
        ' the argument array is created on the fly. Display the 
        ' property value.
        Dim o2 As Object = Activator.CreateInstance(t, _
            New Object() { 5280 })
        Console.WriteLine("o2.Number: {0}", pi.GetValue(o2, Nothing))
      
    End Sub  
End Class

' This code produces the following output:
'
'o1.Number: 42
'o1.Number: 127
'o1.MyMethod(22): 2794
'o2.Number: 5280

Sampel kode berikut menunjukkan cara membuat jenis secara dinamis dengan menggunakan TypeBuilder.

using System;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;

class TestILGenerator
{
    public static Type DynamicDotProductGen()
    {
       Type ivType = null;
       Type[] ctorParams = new Type[] { typeof(int),
                                typeof(int),
                        typeof(int)};
    
       AppDomain myDomain = Thread.GetDomain();
       AssemblyName myAsmName = new AssemblyName();
       myAsmName.Name = "IntVectorAsm";
    
       AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
                      myAsmName,
                      AssemblyBuilderAccess.RunAndSave);

       ModuleBuilder IntVectorModule = myAsmBuilder.DefineDynamicModule("IntVectorModule",
                                        "Vector.dll");

       TypeBuilder ivTypeBld = IntVectorModule.DefineType("IntVector",
                                      TypeAttributes.Public);

       FieldBuilder xField = ivTypeBld.DefineField("x", typeof(int),
                                                       FieldAttributes.Private);
       FieldBuilder yField = ivTypeBld.DefineField("y", typeof(int),
                                                       FieldAttributes.Private);
       FieldBuilder zField = ivTypeBld.DefineField("z", typeof(int),
                                                       FieldAttributes.Private);

           Type objType = Type.GetType("System.Object");
           ConstructorInfo objCtor = objType.GetConstructor(new Type[0]);

       ConstructorBuilder ivCtor = ivTypeBld.DefineConstructor(
                      MethodAttributes.Public,
                      CallingConventions.Standard,
                      ctorParams);
       ILGenerator ctorIL = ivCtor.GetILGenerator();
           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Call, objCtor);
           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Ldarg_1);
           ctorIL.Emit(OpCodes.Stfld, xField);
           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Ldarg_2);
           ctorIL.Emit(OpCodes.Stfld, yField);
           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Ldarg_3);
           ctorIL.Emit(OpCodes.Stfld, zField);
       ctorIL.Emit(OpCodes.Ret);

       // This method will find the dot product of the stored vector
       // with another.

       Type[] dpParams = new Type[] { ivTypeBld };

           // Here, you create a MethodBuilder containing the
       // name, the attributes (public, static, private, and so on),
       // the return type (int, in this case), and a array of Type
       // indicating the type of each parameter. Since the sole parameter
       // is a IntVector, the very class you're creating, you will
       // pass in the TypeBuilder (which is derived from Type) instead of
       // a Type object for IntVector, avoiding an exception.

       // -- This method would be declared in C# as:
       //    public int DotProduct(IntVector aVector)

           MethodBuilder dotProductMthd = ivTypeBld.DefineMethod(
                                  "DotProduct",
                          MethodAttributes.Public,
                                          typeof(int),
                                          dpParams);

       // A ILGenerator can now be spawned, attached to the MethodBuilder.

       ILGenerator mthdIL = dotProductMthd.GetILGenerator();
    
       // Here's the body of our function, in MSIL form. We're going to find the
       // "dot product" of the current vector instance with the passed vector
       // instance. For reference purposes, the equation is:
       // (x1 * x2) + (y1 * y2) + (z1 * z2) = the dot product

       // First, you'll load the reference to the current instance "this"
       // stored in argument 0 (ldarg.0) onto the stack. Ldfld, the subsequent
       // instruction, will pop the reference off the stack and look up the
       // field "x", specified by the FieldInfo token "xField".

       mthdIL.Emit(OpCodes.Ldarg_0);
       mthdIL.Emit(OpCodes.Ldfld, xField);

       // That completed, the value stored at field "x" is now atop the stack.
       // Now, you'll do the same for the object reference we passed as a
       // parameter, stored in argument 1 (ldarg.1). After Ldfld executed,
       // you'll have the value stored in field "x" for the passed instance
       // atop the stack.

       mthdIL.Emit(OpCodes.Ldarg_1);
       mthdIL.Emit(OpCodes.Ldfld, xField);

           // There will now be two values atop the stack - the "x" value for the
       // current vector instance, and the "x" value for the passed instance.
       // You'll now multiply them, and push the result onto the evaluation stack.

       mthdIL.Emit(OpCodes.Mul_Ovf_Un);

       // Now, repeat this for the "y" fields of both vectors.

       mthdIL.Emit(OpCodes.Ldarg_0);
       mthdIL.Emit(OpCodes.Ldfld, yField);
       mthdIL.Emit(OpCodes.Ldarg_1);
       mthdIL.Emit(OpCodes.Ldfld, yField);
       mthdIL.Emit(OpCodes.Mul_Ovf_Un);

       // At this time, the results of both multiplications should be atop
       // the stack. You'll now add them and push the result onto the stack.

       mthdIL.Emit(OpCodes.Add_Ovf_Un);

       // Multiply both "z" field and push the result onto the stack.
       mthdIL.Emit(OpCodes.Ldarg_0);
       mthdIL.Emit(OpCodes.Ldfld, zField);
       mthdIL.Emit(OpCodes.Ldarg_1);
       mthdIL.Emit(OpCodes.Ldfld, zField);
       mthdIL.Emit(OpCodes.Mul_Ovf_Un);

       // Finally, add the result of multiplying the "z" fields with the
       // result of the earlier addition, and push the result - the dot product -
       // onto the stack.
       mthdIL.Emit(OpCodes.Add_Ovf_Un);

       // The "ret" opcode will pop the last value from the stack and return it
       // to the calling method. You're all done!

       mthdIL.Emit(OpCodes.Ret);

       ivType = ivTypeBld.CreateType();

       return ivType;
    }

    public static void Main() {
    
       Type IVType = null;
           object aVector1 = null;
           object aVector2 = null;
       Type[] aVtypes = new Type[] {typeof(int), typeof(int), typeof(int)};
           object[] aVargs1 = new object[] {10, 10, 10};
           object[] aVargs2 = new object[] {20, 20, 20};
    
       // Call the  method to build our dynamic class.

       IVType = DynamicDotProductGen();

           Console.WriteLine("---");

       ConstructorInfo myDTctor = IVType.GetConstructor(aVtypes);
       aVector1 = myDTctor.Invoke(aVargs1);
       aVector2 = myDTctor.Invoke(aVargs2);

       object[] passMe = new object[1];
           passMe[0] = (object)aVector2;

       Console.WriteLine("(10, 10, 10) . (20, 20, 20) = {0}",
                 IVType.InvokeMember("DotProduct",
                          BindingFlags.InvokeMethod,
                          null,
                          aVector1,
                          passMe));

       // +++ OUTPUT +++
       // ---
       // (10, 10, 10) . (20, 20, 20) = 600
    }
}

Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit

 _


Class TestILGenerator
   
   
   Public Shared Function DynamicDotProductGen() As Type
      
      Dim ivType As Type = Nothing
      Dim ctorParams() As Type = {GetType(Integer), GetType(Integer), GetType(Integer)}
      
      Dim myDomain As AppDomain = Thread.GetDomain()
      Dim myAsmName As New AssemblyName()
      myAsmName.Name = "IntVectorAsm"
      
      Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly( _
                        myAsmName, _
                        AssemblyBuilderAccess.RunAndSave)
      
      Dim IntVectorModule As ModuleBuilder = myAsmBuilder.DefineDynamicModule( _
                         "IntVectorModule", _
                         "Vector.dll")
      
      Dim ivTypeBld As TypeBuilder = IntVectorModule.DefineType("IntVector", TypeAttributes.Public)
      
      Dim xField As FieldBuilder = ivTypeBld.DefineField("x", _
                                 GetType(Integer), _
                                 FieldAttributes.Private)
      Dim yField As FieldBuilder = ivTypeBld.DefineField("y", _ 
                                 GetType(Integer), _
                                 FieldAttributes.Private)
      Dim zField As FieldBuilder = ivTypeBld.DefineField("z", _
                                 GetType(Integer), _
                                 FieldAttributes.Private)
      
      
      Dim objType As Type = Type.GetType("System.Object")
      Dim objCtor As ConstructorInfo = objType.GetConstructor(New Type() {})
      
      Dim ivCtor As ConstructorBuilder = ivTypeBld.DefineConstructor( _
                     MethodAttributes.Public, _
                     CallingConventions.Standard, _
                     ctorParams)
      Dim ctorIL As ILGenerator = ivCtor.GetILGenerator()
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Call, objCtor)
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_1)
      ctorIL.Emit(OpCodes.Stfld, xField)
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_2)
      ctorIL.Emit(OpCodes.Stfld, yField)
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_3)
      ctorIL.Emit(OpCodes.Stfld, zField)
      ctorIL.Emit(OpCodes.Ret)
     

      ' Now, you'll construct the method find the dot product of two vectors. First,
      ' let's define the parameters that will be accepted by the method. In this case,
      ' it's an IntVector itself!

      Dim dpParams() As Type = {ivTypeBld}
      
      ' Here, you create a MethodBuilder containing the
      ' name, the attributes (public, static, private, and so on),
      ' the return type (int, in this case), and a array of Type
      ' indicating the type of each parameter. Since the sole parameter
      ' is a IntVector, the very class you're creating, you will
      ' pass in the TypeBuilder (which is derived from Type) instead of 
      ' a Type object for IntVector, avoiding an exception. 
      ' -- This method would be declared in VB.NET as:
      '    Public Function DotProduct(IntVector aVector) As Integer

      Dim dotProductMthd As MethodBuilder = ivTypeBld.DefineMethod("DotProduct", _
                        MethodAttributes.Public, GetType(Integer), _
                                            dpParams)
      
      ' A ILGenerator can now be spawned, attached to the MethodBuilder.
      Dim mthdIL As ILGenerator = dotProductMthd.GetILGenerator()
      
      ' Here's the body of our function, in MSIL form. We're going to find the
      ' "dot product" of the current vector instance with the passed vector 
      ' instance. For reference purposes, the equation is:
      ' (x1 * x2) + (y1 * y2) + (z1 * z2) = the dot product
      ' First, you'll load the reference to the current instance "this"
      ' stored in argument 0 (ldarg.0) onto the stack. Ldfld, the subsequent
      ' instruction, will pop the reference off the stack and look up the
      ' field "x", specified by the FieldInfo token "xField".
      mthdIL.Emit(OpCodes.Ldarg_0)
      mthdIL.Emit(OpCodes.Ldfld, xField)
      
      ' That completed, the value stored at field "x" is now atop the stack.
      ' Now, you'll do the same for the object reference we passed as a
      ' parameter, stored in argument 1 (ldarg.1). After Ldfld executed,
      ' you'll have the value stored in field "x" for the passed instance
      ' atop the stack.
      mthdIL.Emit(OpCodes.Ldarg_1)
      mthdIL.Emit(OpCodes.Ldfld, xField)
      
      ' There will now be two values atop the stack - the "x" value for the
      ' current vector instance, and the "x" value for the passed instance.
      ' You'll now multiply them, and push the result onto the evaluation stack.
      mthdIL.Emit(OpCodes.Mul_Ovf_Un)
      
      ' Now, repeat this for the "y" fields of both vectors.
      mthdIL.Emit(OpCodes.Ldarg_0)
      mthdIL.Emit(OpCodes.Ldfld, yField)
      mthdIL.Emit(OpCodes.Ldarg_1)
      mthdIL.Emit(OpCodes.Ldfld, yField)
      mthdIL.Emit(OpCodes.Mul_Ovf_Un)
      
      ' At this time, the results of both multiplications should be atop
      ' the stack. You'll now add them and push the result onto the stack.
      mthdIL.Emit(OpCodes.Add_Ovf_Un)
      
      ' Multiply both "z" field and push the result onto the stack.
      mthdIL.Emit(OpCodes.Ldarg_0)
      mthdIL.Emit(OpCodes.Ldfld, zField)
      mthdIL.Emit(OpCodes.Ldarg_1)
      mthdIL.Emit(OpCodes.Ldfld, zField)
      mthdIL.Emit(OpCodes.Mul_Ovf_Un)
      
      ' Finally, add the result of multiplying the "z" fields with the
      ' result of the earlier addition, and push the result - the dot product -
      ' onto the stack.
      mthdIL.Emit(OpCodes.Add_Ovf_Un)
      
      ' The "ret" opcode will pop the last value from the stack and return it
      ' to the calling method. You're all done!
      mthdIL.Emit(OpCodes.Ret)
      
      
      ivType = ivTypeBld.CreateType()
      
      Return ivType
   End Function 'DynamicDotProductGen
    
   
   Public Shared Sub Main()
      
      Dim IVType As Type = Nothing
      Dim aVector1 As Object = Nothing
      Dim aVector2 As Object = Nothing
      Dim aVtypes() As Type = {GetType(Integer), GetType(Integer), GetType(Integer)}
      Dim aVargs1() As Object = {10, 10, 10}
      Dim aVargs2() As Object = {20, 20, 20}
      
      ' Call the  method to build our dynamic class.
      IVType = DynamicDotProductGen()
      
      
      Dim myDTctor As ConstructorInfo = IVType.GetConstructor(aVtypes)
      aVector1 = myDTctor.Invoke(aVargs1)
      aVector2 = myDTctor.Invoke(aVargs2)
      
      Console.WriteLine("---")
      Dim passMe(0) As Object
      passMe(0) = CType(aVector2, Object)
      
      Console.WriteLine("(10, 10, 10) . (20, 20, 20) = {0}", _
                        IVType.InvokeMember("DotProduct", BindingFlags.InvokeMethod, _
                        Nothing, aVector1, passMe))
   End Sub
End Class



' +++ OUTPUT +++
' ---
' (10, 10, 10) . (20, 20, 20) = 600

Keterangan

Untuk informasi selengkapnya tentang API ini, lihat Keterangan API Tambahan untuk TypeBuilder.

Konstruktor

Nama	Deskripsi
TypeBuilder()	Menginisialisasi instans baru dari kelas TypeBuilder.

Bidang

Nama	Deskripsi
UnspecifiedTypeSize	Mewakili bahwa ukuran total untuk jenis tidak ditentukan.

Properti

Nama	Deskripsi
Assembly	Mengambil rakitan dinamis yang berisi definisi jenis ini.
AssemblyQualifiedName	Mengembalikan nama lengkap jenis ini yang memenuhi syarat dengan nama tampilan rakitan.
BaseType	Mengambil tipe dasar jenis ini.
CustomAttributes	Mendapatkan koleksi yang berisi atribut kustom anggota ini. (Diperoleh dari MemberInfo)
DeclaredConstructors	Mendapatkan koleksi konstruktor yang dideklarasikan oleh jenis saat ini. (Diperoleh dari TypeInfo)
DeclaredEvents	Mendapatkan kumpulan peristiwa yang ditentukan oleh jenis saat ini. (Diperoleh dari TypeInfo)
DeclaredFields	Mendapatkan kumpulan bidang yang ditentukan oleh jenis saat ini. (Diperoleh dari TypeInfo)
DeclaredMembers	Mendapatkan kumpulan anggota yang ditentukan oleh jenis saat ini. (Diperoleh dari TypeInfo)
DeclaredMethods	Mendapatkan kumpulan metode yang ditentukan oleh jenis saat ini. (Diperoleh dari TypeInfo)
DeclaredNestedTypes	Mendapatkan kumpulan jenis berlapis yang ditentukan oleh jenis saat ini. (Diperoleh dari TypeInfo)
DeclaredProperties	Mendapatkan kumpulan properti yang ditentukan oleh jenis saat ini. (Diperoleh dari TypeInfo)
DeclaringMethod	Mendapatkan metode yang mendeklarasikan parameter jenis generik saat ini.
DeclaringType	Mengembalikan tipe yang mendeklarasikan tipe ini.
FullName	Mengambil jalur lengkap tipe ini.
GenericParameterAttributes	Mendapatkan nilai yang menunjukkan kovariansi dan batasan khusus dari parameter jenis generik saat ini.
GenericParameterPosition	Mendapatkan posisi parameter jenis dalam daftar parameter jenis jenis generik yang mendeklarasikan parameter.
GenericTypeParameters	Mendapatkan array parameter jenis generik dari instans saat ini. (Diperoleh dari TypeInfo)
GUID	Mengambil GUID tipe ini.
ImplementedInterfaces	Mendapatkan koleksi antarmuka yang diimplementasikan oleh jenis saat ini. (Diperoleh dari TypeInfo)
IsByRefLike	Mendapatkan nilai yang menunjukkan apakah jenisnya adalah struktur seperti byref.
IsCollectible	Mendapatkan nilai yang menunjukkan apakah objek ini MemberInfo mereferensikan satu atau beberapa rakitan yang disimpan dalam koleksi AssemblyLoadContext. (Diperoleh dari MemberInfo)
IsConstructedGenericType	Mendapatkan nilai yang menunjukkan apakah objek ini mewakili jenis generik yang dibangun.
IsContextful	Mendapatkan nilai yang menunjukkan apakah Type dapat dihosting dalam konteks. (Diperoleh dari Type)
IsFunctionPointer	Mendapatkan nilai yang menunjukkan apakah saat ini Type adalah penunjuk fungsi. (Diperoleh dari Type)
IsGenericMethodParameter	Mendapatkan nilai yang menunjukkan apakah saat ini Type mewakili parameter jenis dalam definisi metode generik. (Diperoleh dari Type)
IsGenericParameter	Mendapatkan nilai yang menunjukkan apakah jenis saat ini adalah parameter jenis generik.
IsGenericType	Mendapatkan nilai yang menunjukkan apakah jenis saat ini adalah jenis generik.
IsGenericTypeDefinition	Mendapatkan nilai yang menunjukkan apakah saat ini TypeBuilder mewakili definisi jenis generik dari mana jenis generik lainnya dapat dibangun.
IsGenericTypeParameter	Mendapatkan nilai yang menunjukkan apakah saat ini Type mewakili parameter jenis dalam definisi jenis generik. (Diperoleh dari Type)
IsSecurityCritical	Mendapatkan nilai yang menunjukkan apakah jenis saat ini kritis terhadap keamanan atau keamanan-kritis, dan oleh karena itu dapat melakukan operasi penting.
IsSecuritySafeCritical	Mendapatkan nilai yang menunjukkan apakah jenis saat ini kritis terhadap keamanan; yaitu, apakah dapat melakukan operasi penting dan dapat diakses dengan kode transparan.
IsSecurityTransparent	Mendapatkan nilai yang menunjukkan apakah jenis saat ini transparan, dan karenanya tidak dapat melakukan operasi penting.
IsSignatureType	Mendapatkan nilai yang menunjukkan apakah jenis tersebut adalah jenis tanda tangan. (Diperoleh dari Type)
IsSZArray	Menentukan dan membuat instans kelas baru selama run time.
IsTypeDefinition	Menentukan dan membuat instans kelas baru selama run time.
IsUnmanagedFunctionPointer	Mendapatkan nilai yang menunjukkan apakah saat ini Type adalah penunjuk fungsi yang tidak dikelola. (Diperoleh dari Type)
IsVariableBoundArray	Mendapatkan nilai yang menunjukkan apakah jenisnya adalah jenis array yang dapat mewakili array multi-dimensi atau array dengan batas bawah arbitrer. (Diperoleh dari Type)
MetadataToken	Mendapatkan token yang mengidentifikasi modul dinamis saat ini dalam metadata.
Module	Mengambil modul dinamis yang berisi definisi jenis ini.
Name	Mengambil nama tipe ini.
Namespace	Mengambil namespace tempat ini TypeBuilder ditentukan.
PackingSize	Mengambil ukuran pengemasan jenis ini.
PackingSizeCore	Ketika ditimpa di kelas turunan, mendapatkan ukuran pengemasan jenis ini.
ReflectedType	Mengembalikan tipe yang digunakan untuk mendapatkan tipe ini.
Size	Mengambil ukuran total jenis.
SizeCore	Ketika ditimpa dalam kelas turunan, mendapatkan ukuran total jenis.
TypeHandle	Tidak didukung dalam modul dinamis.
UnderlyingSystemType	Mengembalikan jenis sistem yang mendasar untuk ini TypeBuilder.

Metode

Nama	Deskripsi
AddInterfaceImplementation(Type)	Menambahkan antarmuka yang diterapkan jenis ini.
AddInterfaceImplementationCore(Type)	Saat ditimpa di kelas turunan, menambahkan antarmuka yang diterapkan jenis ini.
AsType()	Mengembalikan jenis saat ini sebagai Type objek. (Diperoleh dari TypeInfo)
CreateType()	Type Membuat objek untuk kelas . Setelah menentukan bidang dan metode pada kelas, CreateType dipanggil untuk memuat objeknya Type .
CreateTypeInfo()	TypeInfo Mendapatkan objek yang mewakili jenis ini.
CreateTypeInfoCore()	Ketika ditimpa dalam kelas turunan, mendapatkan TypeInfo objek yang mewakili jenis ini.
DefineConstructor(MethodAttributes, CallingConventions, Type[], Type[][], Type[][])	Menambahkan konstruktor baru ke jenis , dengan atribut, tanda tangan, dan pengubah kustom tertentu.
DefineConstructor(MethodAttributes, CallingConventions, Type[])	Menambahkan konstruktor baru ke jenis , dengan atribut dan tanda tangan yang diberikan.
DefineConstructorCore(MethodAttributes, CallingConventions, Type[], Type[][], Type[][])	Saat ditimpa di kelas turunan, menambahkan konstruktor baru ke jenis , dengan atribut, tanda tangan, dan pengubah kustom yang diberikan.
DefineDefaultConstructor(MethodAttributes)	Menentukan konstruktor tanpa parameter. Konstruktor yang ditentukan di sini hanya akan memanggil konstruktor tanpa parameter induk.
DefineDefaultConstructorCore(MethodAttributes)	Saat ditimpa dalam kelas turunan, menentukan konstruktor tanpa parameter. Konstruktor yang ditentukan di sini memanggil konstruktor tanpa parameter induk.
DefineEvent(String, EventAttributes, Type)	Menambahkan peristiwa baru ke jenis , dengan nama, atribut, dan jenis peristiwa yang diberikan.
DefineEventCore(String, EventAttributes, Type)	Saat ditimpa di kelas turunan, menambahkan peristiwa baru ke jenis , dengan nama, atribut, dan jenis peristiwa yang diberikan.
DefineField(String, Type, FieldAttributes)	Menambahkan bidang baru ke jenis , dengan nama, atribut, dan jenis bidang yang diberikan.
DefineField(String, Type, Type[], Type[], FieldAttributes)	Menambahkan bidang baru ke jenis , dengan nama, atribut, jenis bidang, dan pengubah kustom yang diberikan.
DefineFieldCore(String, Type, Type[], Type[], FieldAttributes)	Saat ditimpa di kelas turunan, menambahkan bidang baru ke jenis , dengan nama, atribut, jenis bidang, dan pengubah kustom yang diberikan.
DefineGenericParameters(String[])	Menentukan parameter jenis generik untuk jenis saat ini, menentukan jumlah dan namanya, dan mengembalikan array GenericTypeParameterBuilder objek yang dapat digunakan untuk mengatur batasannya.
DefineGenericParametersCore(String[])	Saat ditimpa dalam kelas turunan, menentukan parameter jenis generik untuk jenis saat ini, menentukan jumlah dan namanya.
DefineInitializedData(String, Byte[], FieldAttributes)	Menentukan bidang data yang diinisialisasi di bagian .sdata dari file portable executable (PE).
DefineInitializedDataCore(String, Byte[], FieldAttributes)	Saat ditimpa dalam kelas turunan, tentukan bidang data yang diinisialisasi di bagian .sdata dari file portable executable (PE).
DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Menambahkan metode baru ke jenis , dengan nama yang ditentukan, atribut metode, konvensi panggilan, tanda tangan metode, dan pengubah kustom.
DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[])	Menambahkan metode baru ke jenis , dengan nama, atribut metode, konvensi panggilan, dan tanda tangan metode yang ditentukan.
DefineMethod(String, MethodAttributes, CallingConventions)	Menambahkan metode baru ke jenis , dengan nama, atribut metode, dan konvensi panggilan yang ditentukan.
DefineMethod(String, MethodAttributes, Type, Type[])	Menambahkan metode baru ke jenis , dengan nama, atribut metode, dan tanda tangan metode yang ditentukan.
DefineMethod(String, MethodAttributes)	Menambahkan metode baru ke jenis , dengan atribut nama dan metode yang ditentukan.
DefineMethodCore(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Saat ditimpa di kelas turunan, menambahkan metode baru ke jenis , dengan nama, atribut metode, konvensi panggilan, tanda tangan metode, dan pengubah kustom yang ditentukan.
DefineMethodOverride(MethodInfo, MethodInfo)	Menentukan isi metode tertentu yang mengimplementasikan deklarasi metode tertentu, berpotensi dengan nama yang berbeda.
DefineMethodOverrideCore(MethodInfo, MethodInfo)	Ketika ditimpa dalam kelas turunan, menentukan isi metode tertentu yang mengimplementasikan deklarasi metode tertentu, berpotensi dengan nama yang berbeda.
DefineNestedType(String, TypeAttributes, Type, Int32)	Mendefinisikan jenis berlapis, mengingat nama, atribut, ukuran total jenis, dan jenis yang diperluasnya.
DefineNestedType(String, TypeAttributes, Type, PackingSize, Int32)	Menentukan jenis berlapis, mengingat nama, atribut, ukuran, dan jenis yang diperluasnya.
DefineNestedType(String, TypeAttributes, Type, PackingSize)	Mendefinisikan jenis berlapis, mengingat nama, atribut, jenis yang diperluasnya, dan ukuran kemasannya.
DefineNestedType(String, TypeAttributes, Type, Type[])	Mendefinisikan jenis berlapis, mengingat nama, atribut, jenis yang diperluasnya, dan antarmuka yang diterapkannya.
DefineNestedType(String, TypeAttributes, Type)	Menentukan jenis berlapis, mengingat nama, atribut, dan jenis yang diperluasnya.
DefineNestedType(String, TypeAttributes)	Menentukan jenis berlapis, mengingat nama dan atributnya.
DefineNestedType(String)	Mendefinisikan jenis berlapis, mengingat namanya.
DefineNestedTypeCore(String, TypeAttributes, Type, Type[], PackingSize, Int32)	Saat ditimpa dalam kelas turunan, menentukan jenis berlapis, mengingat nama, atribut, ukuran, dan jenis yang diperluasnya.
DefinePInvokeMethod(String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Mendefinisikan metode yang PInvoke diberi namanya, nama DLL tempat metode ditentukan, atribut metode, konvensi pemanggilan metode, jenis pengembalian metode, jenis parameter metode, dan PInvoke bendera.
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Mendefinisikan metode yang PInvoke diberikan namanya, nama DLL tempat metode ditentukan, nama titik masuk, atribut metode, konvensi panggilan metode, jenis pengembalian metode, jenis parameter metode, dan PInvoke bendera.
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][], CallingConvention, CharSet)	Mendefinisikan metode yang PInvoke diberikan namanya, nama DLL tempat metode ditentukan, nama titik masuk, atribut metode, konvensi panggilan metode, jenis pengembalian metode, jenis parameter metode, jenis parameter metode, PInvoke bendera, dan pengubah kustom untuk parameter dan jenis pengembalian.
DefinePInvokeMethodCore(String, String, String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][], CallingConvention, CharSet)	Saat ditimpa dalam kelas turunan, menentukan metode PInvoke dengan nama yang disediakan, nama DLL, nama titik masuk, atribut, konvensi panggilan, jenis pengembalian, jenis parameter, bendera PInvoke, dan pengubah kustom untuk parameter dan jenis pengembalian.
DefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Menambahkan properti baru ke jenis , dengan nama yang diberikan, konvensi panggilan, tanda tangan properti, dan pengubah kustom.
DefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[])	Menambahkan properti baru ke jenis , dengan nama, atribut, konvensi panggilan, dan tanda tangan properti yang diberikan.
DefineProperty(String, PropertyAttributes, Type, Type[], Type[], Type[], Type[][], Type[][])	Menambahkan properti baru ke jenis , dengan nama yang diberikan, tanda tangan properti, dan pengubah kustom.
DefineProperty(String, PropertyAttributes, Type, Type[])	Menambahkan properti baru ke jenis , dengan nama dan tanda tangan properti yang diberikan.
DefinePropertyCore(String, PropertyAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Saat ditimpa di kelas turunan, menambahkan properti baru ke jenis , dengan nama tertentu, konvensi panggilan, tanda tangan properti, dan pengubah kustom.
DefineTypeInitializer()	Menentukan penginisialisasi untuk jenis ini.
DefineTypeInitializerCore()	Saat ditimpa dalam kelas turunan, menentukan penginisialisasi untuk jenis ini.
DefineUninitializedData(String, Int32, FieldAttributes)	Menentukan bidang data yang tidak diinisialisasi di bagian .sdata file portable executable (PE).
DefineUninitializedDataCore(String, Int32, FieldAttributes)	Saat ditimpa dalam kelas turunan, menentukan bidang data yang tidak diinisialisasi di .sdata bagian file portable executable (PE).
Equals(Object)	Menentukan apakah jenis sistem yang mendasar dari objek saat ini Type sama dengan jenis sistem yang mendasar dari yang ditentukan Object. (Diperoleh dari Type)
Equals(Type)	Menentukan apakah jenis sistem yang mendasar dari saat ini Type sama dengan jenis sistem yang mendasar dari yang ditentukan Type. (Diperoleh dari Type)
GetAttributeFlagsImpl()	Ketika ditimpa dalam kelas turunan, mengimplementasikan Attributes properti dan mendapatkan kombinasi bitwise dari nilai enumerasi yang menunjukkan atribut yang terkait dengan Type.
GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Mencari konstruktor yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan konvensi panggilan yang ditentukan. (Diperoleh dari Type)
GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])	Mencari konstruktor yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan. (Diperoleh dari Type)
GetConstructor(BindingFlags, Type[])	Mencari konstruktor yang parameternya cocok dengan jenis argumen yang ditentukan, menggunakan batasan pengikatan yang ditentukan. (Diperoleh dari Type)
GetConstructor(Type, ConstructorInfo)	Mengembalikan konstruktor dari jenis generik yang dibuat yang ditentukan yang sesuai dengan konstruktor yang ditentukan dari definisi jenis generik.
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Saat ditimpa di kelas turunan, mencari konstruktor yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan konvensi panggilan yang ditentukan.
GetConstructors(BindingFlags)	Mengembalikan array ConstructorInfo objek yang mewakili konstruktor publik dan non-publik yang ditentukan untuk kelas ini, seperti yang ditentukan.
GetCustomAttributes(Boolean)	Mengembalikan semua atribut kustom yang ditentukan untuk jenis ini.
GetCustomAttributes(Type, Boolean)	Mengembalikan semua atribut kustom dari jenis saat ini yang dapat ditetapkan ke jenis tertentu.
GetCustomAttributesData()	Mengembalikan daftar objek CustomAttributeData yang mewakili data tentang atribut yang telah diterapkan ke anggota target. (Diperoleh dari MemberInfo)
GetDeclaredEvent(String)	Mengembalikan objek yang mewakili peristiwa yang ditentukan yang dideklarasikan oleh jenis saat ini. (Diperoleh dari TypeInfo)
GetDeclaredField(String)	Mengembalikan objek yang mewakili bidang yang ditentukan yang dideklarasikan oleh jenis saat ini. (Diperoleh dari TypeInfo)
GetDeclaredMethod(String)	Mengembalikan objek yang mewakili metode yang ditentukan yang dideklarasikan oleh jenis saat ini. (Diperoleh dari TypeInfo)
GetDeclaredMethods(String)	Mengembalikan koleksi yang berisi semua metode yang dideklarasikan pada jenis saat ini yang cocok dengan nama yang ditentukan. (Diperoleh dari TypeInfo)
GetDeclaredNestedType(String)	Mengembalikan objek yang mewakili jenis berlapis yang ditentukan yang dideklarasikan oleh jenis saat ini. (Diperoleh dari TypeInfo)
GetDeclaredProperty(String)	Mengembalikan objek yang mewakili properti yang ditentukan yang dideklarasikan oleh jenis saat ini. (Diperoleh dari TypeInfo)
GetElementType()	Memanggil metode ini selalu melemparkan NotSupportedException.
GetEnumValuesAsUnderlyingType()	Mengambil array nilai dari konstanta jenis dasar dari jenis enumerasi ini. (Diperoleh dari Type)
GetEvent(String, BindingFlags)	Mengembalikan peristiwa dengan nama yang ditentukan.
GetEvents()	Mengembalikan peristiwa publik yang dideklarasikan atau diwarisi oleh jenis ini.
GetEvents(BindingFlags)	Mengembalikan peristiwa publik dan non-publik yang dideklarasikan oleh jenis ini.
GetField(String, BindingFlags)	Mengembalikan bidang yang ditentukan oleh nama yang diberikan.
GetField(Type, FieldInfo)	Mengembalikan bidang dari jenis generik yang dibuat yang ditentukan yang sesuai dengan bidang yang ditentukan dari definisi jenis generik.
GetFields(BindingFlags)	Mengembalikan bidang publik dan non-publik yang dideklarasikan oleh jenis ini.
GetFunctionPointerCallingConventions()	Saat ditimpa di kelas turunan, mengembalikan konvensi panggilan penunjuk Typefungsi saat ini . (Diperoleh dari Type)
GetFunctionPointerParameterTypes()	Saat ditimpa di kelas turunan, mengembalikan jenis parameter penunjuk Typefungsi saat ini . (Diperoleh dari Type)
GetFunctionPointerReturnType()	Saat ditimpa di kelas turunan, mengembalikan jenis pengembalian penunjuk Typefungsi saat ini . (Diperoleh dari Type)
GetGenericArguments()	Mengembalikan array Type objek yang mewakili argumen jenis jenis generik atau parameter jenis definisi jenis generik.
GetGenericTypeDefinition()	Mengembalikan Type objek yang mewakili definisi jenis generik dari mana jenis saat ini dapat diperoleh.
GetHashCode()	Mengembalikan kode hash untuk instans ini. (Diperoleh dari Type)
GetInterface(String, Boolean)	Mengembalikan antarmuka yang diimplementasikan (secara langsung atau tidak langsung) oleh kelas ini dengan nama yang sepenuhnya memenuhi syarat yang cocok dengan nama antarmuka yang diberikan.
GetInterfaceMap(Type)	Mengembalikan pemetaan antarmuka untuk antarmuka yang diminta.
GetInterfaces()	Mengembalikan array dari semua antarmuka yang diimplementasikan pada jenis ini dan jenis dasarnya.
GetMember(String, MemberTypes, BindingFlags)	Mengembalikan semua anggota publik dan non-publik yang dinyatakan atau diwarisi oleh jenis ini, seperti yang ditentukan.
GetMembers(BindingFlags)	Mengembalikan anggota untuk anggota publik dan non-publik yang dinyatakan atau diwarisi oleh jenis ini.
GetMemberWithSameMetadataDefinitionAs(MemberInfo)	Mencari MemberInfo pada saat ini Type yang cocok dengan yang ditentukan MemberInfo. (Diperoleh dari Type)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Mencari metode yang ditentukan yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan konvensi panggilan yang ditentukan. (Diperoleh dari Type)
GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])	Mencari metode yang ditentukan yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan. (Diperoleh dari Type)
GetMethod(String, BindingFlags, Type[])	Mencari metode yang ditentukan yang parameternya cocok dengan jenis argumen yang ditentukan, menggunakan batasan pengikatan yang ditentukan. (Diperoleh dari Type)
GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Mencari metode yang ditentukan yang parameternya cocok dengan jumlah parameter generik, jenis argumen, dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan konvensi panggilan yang ditentukan. (Diperoleh dari Type)
GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[])	Mencari metode yang ditentukan yang parameternya cocok dengan jumlah parameter generik, jenis argumen, dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan. (Diperoleh dari Type)
GetMethod(String, Int32, BindingFlags, Type[])	Mencari metode yang ditentukan yang parameternya cocok dengan jumlah parameter generik dan jenis argumen yang ditentukan, menggunakan batasan pengikatan yang ditentukan. (Diperoleh dari Type)
GetMethod(String, Int32, Type[], ParameterModifier[])	Mencari metode publik yang ditentukan yang parameternya cocok dengan jumlah parameter generik, jenis argumen, dan pengubah yang ditentukan. (Diperoleh dari Type)
GetMethod(String, Int32, Type[])	Mencari metode publik yang ditentukan yang parameternya cocok dengan jumlah parameter generik dan jenis argumen yang ditentukan. (Diperoleh dari Type)
GetMethod(Type, MethodInfo)	Mengembalikan metode dari jenis generik yang dibuat yang ditentukan yang sesuai dengan metode yang ditentukan dari definisi jenis generik.
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Saat ditimpa dalam kelas turunan, cari metode yang ditentukan yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan konvensi panggilan yang ditentukan.
GetMethodImpl(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Saat ditimpa dalam kelas turunan, cari metode yang ditentukan yang parameternya cocok dengan jumlah parameter generik, jenis argumen, dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan konvensi panggilan yang ditentukan. (Diperoleh dari Type)
GetMethods(BindingFlags)	Mengembalikan semua metode publik dan non-publik yang dinyatakan atau diwarisi oleh jenis ini, seperti yang ditentukan.
GetNestedType(String, BindingFlags)	Mengembalikan jenis berlapis publik dan non-publik yang dideklarasikan oleh jenis ini.
GetNestedTypes(BindingFlags)	Mengembalikan jenis berlapis publik dan non-publik yang dideklarasikan atau diwarisi oleh jenis ini.
GetOptionalCustomModifiers()	Saat ditimpa di kelas turunan, mengembalikan pengubah kustom opsional dari Type. (Diperoleh dari Type)
GetProperties(BindingFlags)	Mengembalikan semua properti publik dan non-publik yang dideklarasikan atau diwarisi oleh jenis ini, seperti yang ditentukan.
GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Mencari properti yang ditentukan yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan. (Diperoleh dari Type)
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Saat ditimpa di kelas turunan, cari properti yang ditentukan yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan.
GetRequiredCustomModifiers()	Saat ditimpa di kelas turunan, mengembalikan pengubah kustom yang Typediperlukan dari . (Diperoleh dari Type)
GetType()	Mendapatkan .Type (Diperoleh dari Type)
GetTypeCodeImpl()	Mengembalikan kode jenis yang mendasar dari instans ini Type . (Diperoleh dari Type)
HasElementTypeImpl()	Ketika ditimpa dalam kelas turunan, mengimplementasikan HasElementType properti dan menentukan apakah saat ini Type mencakup atau mengacu pada jenis lain; yaitu, apakah saat ini Type adalah array, pointer, atau diteruskan oleh referensi.
HasSameMetadataDefinitionAs(MemberInfo)	Menentukan dan membuat instans kelas baru selama run time. (Diperoleh dari MemberInfo)
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)	Memanggil anggota yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan cocok dengan daftar argumen dan budaya yang ditentukan. (Diperoleh dari Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])	Memanggil anggota yang ditentukan. Metode yang akan dipanggil harus dapat diakses dan memberikan kecocokan paling spesifik dengan daftar argumen yang ditentukan, di bawah batasan atribut binder dan pemanggilan yang ditentukan.
InvokeMember(String, BindingFlags, Binder, Object, Object[])	Memanggil anggota yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan cocok dengan daftar argumen yang ditentukan. (Diperoleh dari Type)
IsArrayImpl()	Ketika ditimpa dalam kelas turunan, mengimplementasikan IsArray properti dan menentukan apakah Type itu array.
IsAssignableFrom(Type)	Mendapatkan nilai yang menunjukkan apakah yang ditentukan Type dapat ditetapkan ke objek ini.
IsAssignableFrom(TypeInfo)	Mendapatkan nilai yang menunjukkan apakah objek tertentu TypeInfo dapat ditetapkan ke objek ini.
IsAssignableTo(Type)	Menentukan apakah jenis saat ini dapat ditetapkan ke variabel dari yang ditentukan targetType. (Diperoleh dari Type)
IsByRefImpl()	Ketika ditimpa dalam kelas turunan, mengimplementasikan IsByRef properti dan menentukan apakah Type diteruskan oleh referensi.
IsCOMObjectImpl()	Ketika ditimpa dalam kelas turunan, mengimplementasikan IsCOMObject properti dan menentukan apakah Type itu objek COM.
IsContextfulImpl()	IsContextful Menerapkan properti dan menentukan apakah Type dapat dihosting dalam konteks. (Diperoleh dari Type)
IsCreated()	Mengembalikan nilai yang menunjukkan apakah jenis dinamis saat ini telah dibuat.
IsCreatedCore()	Saat ditimpa dalam kelas turunan, mengembalikan nilai yang menunjukkan apakah jenis dinamis saat ini telah dibuat.
IsDefined(Type, Boolean)	Menentukan apakah atribut kustom diterapkan ke jenis saat ini.
IsMarshalByRefImpl()	IsMarshalByRef Mengimplementasikan properti dan menentukan apakah Type di-marshal oleh referensi. (Diperoleh dari Type)
IsPointerImpl()	Ketika ditimpa di kelas turunan, mengimplementasikan IsPointer properti dan menentukan apakah Type itu penunjuk.
IsPrimitiveImpl()	Ketika ditimpa dalam kelas turunan, mengimplementasikan IsPrimitive properti dan menentukan apakah Type itu salah satu jenis primitif.
IsSubclassOf(Type)	Menentukan apakah jenis ini berasal dari tipe tertentu.
IsValueTypeImpl()	IsValueType Mengimplementasikan properti dan menentukan apakah Type adalah jenis nilai; yaitu, bukan kelas atau antarmuka. (Diperoleh dari Type)
MakeArrayType()	Mengembalikan Type objek yang mewakili array satu dimensi dari jenis saat ini, dengan batas nol yang lebih rendah.
MakeArrayType(Int32)	Mengembalikan Type objek yang mewakili array dari jenis saat ini, dengan jumlah dimensi yang ditentukan.
MakeByRefType()	Mengembalikan objek yang mewakili jenis saat ini saat diteruskan sebagai parameter /> di Visual Basic).
MakeGenericType(Type[])	Mengganti elemen array jenis untuk parameter jenis definisi jenis generik saat ini, dan mengembalikan jenis yang dibuat yang dihasilkan.
MakePointerType()	Mengembalikan Type objek yang mewakili jenis penunjuk yang tidak dikelola ke jenis saat ini.
MemberwiseClone()	Membuat salinan dangkal dari Objectsaat ini. (Diperoleh dari Object)
SetCustomAttribute(ConstructorInfo, Byte[])	Mengatur atribut kustom menggunakan blob atribut kustom tertentu.
SetCustomAttribute(CustomAttributeBuilder)	Atur atribut kustom menggunakan pembangun atribut kustom.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Saat ditimpa di kelas turunan, atur atribut kustom pada rakitan ini.
SetParent(Type)	Mengatur jenis dasar jenis yang saat ini sedang dibangun.
SetParentCore(Type)	Ketika ditimpa dalam kelas turunan, mengatur jenis dasar jenis yang saat ini sedang dibangun.
ToString()	Mengembalikan nama jenis yang tidak termasuk namespace layanan.

Implementasi Antarmuka Eksplisit

Nama	Deskripsi
IReflectableType.GetTypeInfo()	Mengembalikan representasi dari jenis saat ini sebagai TypeInfo objek. (Diperoleh dari TypeInfo)

Metode Ekstensi

Nama	Deskripsi
GetConstructor(Type, Type[])	Menentukan dan membuat instans kelas baru selama run time.
GetConstructors(Type, BindingFlags)	Menentukan dan membuat instans kelas baru selama run time.
GetConstructors(Type)	Menentukan dan membuat instans kelas baru selama run time.
GetCustomAttribute(MemberInfo, Type, Boolean)	Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttribute(MemberInfo, Type)	Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.
GetCustomAttribute<T>(MemberInfo, Boolean)	Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttribute<T>(MemberInfo)	Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.
GetCustomAttributes(MemberInfo, Boolean)	Mengambil kumpulan atribut kustom yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttributes(MemberInfo, Type, Boolean)	Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttributes(MemberInfo, Type)	Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.
GetCustomAttributes(MemberInfo)	Mengambil kumpulan atribut kustom yang diterapkan ke anggota tertentu.
GetCustomAttributes<T>(MemberInfo, Boolean)	Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttributes<T>(MemberInfo)	Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.
GetDefaultMembers(Type)	Menentukan dan membuat instans kelas baru selama run time.
GetEvent(Type, String, BindingFlags)	Menentukan dan membuat instans kelas baru selama run time.
GetEvent(Type, String)	Menentukan dan membuat instans kelas baru selama run time.
GetEvents(Type, BindingFlags)	Menentukan dan membuat instans kelas baru selama run time.
GetEvents(Type)	Menentukan dan membuat instans kelas baru selama run time.
GetField(Type, String, BindingFlags)	Menentukan dan membuat instans kelas baru selama run time.
GetField(Type, String)	Menentukan dan membuat instans kelas baru selama run time.
GetFields(Type, BindingFlags)	Menentukan dan membuat instans kelas baru selama run time.
GetFields(Type)	Menentukan dan membuat instans kelas baru selama run time.
GetGenericArguments(Type)	Menentukan dan membuat instans kelas baru selama run time.
GetInterfaces(Type)	Menentukan dan membuat instans kelas baru selama run time.
GetMember(Type, String, BindingFlags)	Menentukan dan membuat instans kelas baru selama run time.
GetMember(Type, String)	Menentukan dan membuat instans kelas baru selama run time.
GetMembers(Type, BindingFlags)	Menentukan dan membuat instans kelas baru selama run time.
GetMembers(Type)	Menentukan dan membuat instans kelas baru selama run time.
GetMetadataToken(MemberInfo)	Mendapatkan token metadata untuk anggota tertentu, jika tersedia.
GetMethod(Type, String, BindingFlags)	Menentukan dan membuat instans kelas baru selama run time.
GetMethod(Type, String, Type[])	Menentukan dan membuat instans kelas baru selama run time.
GetMethods(Type, BindingFlags)	Menentukan dan membuat instans kelas baru selama run time.
GetMethods(Type)	Menentukan dan membuat instans kelas baru selama run time.
GetNestedTypes(Type, BindingFlags)	Menentukan dan membuat instans kelas baru selama run time.
GetProperties(Type, BindingFlags)	Menentukan dan membuat instans kelas baru selama run time.
GetProperties(Type)	Menentukan dan membuat instans kelas baru selama run time.
GetProperty(Type, String, Type, Type[])	Menentukan dan membuat instans kelas baru selama run time.
GetProperty(Type, String, Type)	Menentukan dan membuat instans kelas baru selama run time.
GetProperty(Type, String)	Menentukan dan membuat instans kelas baru selama run time.
GetRuntimeEvent(Type, String)	Mengambil objek yang mewakili peristiwa yang ditentukan.
GetRuntimeEvents(Type)	Mengambil koleksi yang mewakili semua peristiwa yang ditentukan pada jenis tertentu.
GetRuntimeField(Type, String)	Mengambil objek yang mewakili bidang tertentu.
GetRuntimeFields(Type)	Mengambil koleksi yang mewakili semua bidang yang ditentukan pada jenis tertentu.
GetRuntimeInterfaceMap(TypeInfo, Type)	Mengembalikan pemetaan antarmuka untuk jenis yang ditentukan dan antarmuka yang ditentukan.
GetRuntimeMethod(Type, String, Type[])	Mengambil objek yang mewakili metode tertentu.
GetRuntimeMethods(Type)	Mengambil koleksi yang mewakili semua metode yang ditentukan pada jenis tertentu.
GetRuntimeProperties(Type)	Mengambil koleksi yang mewakili semua properti yang ditentukan pada jenis tertentu.
GetRuntimeProperty(Type, String)	Mengambil objek yang mewakili properti tertentu.
GetTypeInfo(Type)	Mengembalikan TypeInfo representasi dari jenis yang ditentukan.
HasMetadataToken(MemberInfo)	Mengembalikan nilai yang menunjukkan apakah token metadata tersedia untuk anggota yang ditentukan.
IsAssignableFrom(Type, Type)	Menentukan dan membuat instans kelas baru selama run time.
IsDefined(MemberInfo, Type, Boolean)	Menunjukkan apakah atribut kustom dari jenis tertentu diterapkan ke anggota tertentu, dan, secara opsional, diterapkan ke leluhurnya.
IsDefined(MemberInfo, Type)	Menunjukkan apakah atribut kustom dari jenis tertentu diterapkan ke anggota tertentu.
IsInstanceOfType(Type, Object)	Menentukan dan membuat instans kelas baru selama run time.

Lihat juga

• Cara: Menentukan Tipe Generik dengan Reflection Emit