TypeBuilder Sınıf

Tanım

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

public ref class TypeBuilder sealed : Type
public ref class TypeBuilder sealed : System::Reflection::TypeInfo
public ref class TypeBuilder abstract : System::Reflection::TypeInfo
public ref class TypeBuilder sealed : Type, System::Runtime::InteropServices::_TypeBuilder
public ref class TypeBuilder sealed : System::Reflection::TypeInfo, System::Runtime::InteropServices::_TypeBuilder
public sealed class TypeBuilder : Type
public sealed class TypeBuilder : System.Reflection.TypeInfo
public abstract class TypeBuilder : System.Reflection.TypeInfo
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
public sealed class TypeBuilder : Type, System.Runtime.InteropServices._TypeBuilder
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class TypeBuilder : Type, System.Runtime.InteropServices._TypeBuilder
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class TypeBuilder : System.Reflection.TypeInfo, System.Runtime.InteropServices._TypeBuilder
type TypeBuilder = class
    inherit Type
type TypeBuilder = class
    inherit TypeInfo
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
type TypeBuilder = class
    inherit Type
    interface _TypeBuilder
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type TypeBuilder = class
    inherit Type
    interface _TypeBuilder
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type TypeBuilder = class
    inherit TypeInfo
    interface _TypeBuilder
Public NotInheritable Class TypeBuilder
Inherits Type
Public NotInheritable Class TypeBuilder
Inherits TypeInfo
Public MustInherit Class TypeBuilder
Inherits TypeInfo
Public NotInheritable Class TypeBuilder
Inherits Type
Implements _TypeBuilder
Public NotInheritable Class TypeBuilder
Inherits TypeInfo
Implements _TypeBuilder
Devralma
TypeBuilder
Devralma
TypeBuilder
Devralma
Öznitelikler
Uygulamalar

Örnekler

Aşağıdaki kod örneğinde dinamik derleme tanımlama ve kullanma gösterilmektedir. Örnek derleme, MyDynamicTypebir özel alanı, özel alanı alan ve ayarlayan bir özelliği, özel alanı başlatan oluşturucuları ve kullanıcı tarafından sağlanan bir sayıyı özel alan değeriyle çarpan ve sonucu döndüren bir yöntemi içeren bir tür içerir.

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

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 Visual C++ the type might look like this:
    /*
      public ref class MyDynamicType
      {
      private:
          int m_number;

      public:
          MyDynamicType() : m_number(42) {};
          MyDynamicType(int initNumber) : m_number(initNumber) {};
      
          property int Number
          {
              int get() { return m_number; }
              void set(int value) { m_number = value; }
          }

          int MyMethod(int multiplier)
          {
              return m_number * multiplier;
          }
      };
    */
      
    AssemblyName^ aName = gcnew 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);
      
    TypeBuilder^ tb = mb->DefineType(
        "MyDynamicType", 
         TypeAttributes::Public);

    // Add a private field of type int (Int32).
    FieldBuilder^ fbNumber = tb->DefineField(
        "m_number", 
        int::typeid, 
        FieldAttributes::Private);

    // Define a constructor that takes an integer argument and 
    // stores it in the private field. 
    array<Type^>^ parameterTypes = { int::typeid };
    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);
    ctor1IL->Emit(OpCodes::Call, 
        Object::typeid->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 nullptr.
    ConstructorBuilder^ ctor0 = tb->DefineConstructor(
        MethodAttributes::Public, 
        CallingConventions::Standard, 
        Type::EmptyTypes);

    ILGenerator^ ctor0IL = ctor0->GetILGenerator();
    ctor0IL->Emit(OpCodes::Ldarg_0);
    ctor0IL->Emit(OpCodes::Call, 
        Object::typeid->GetConstructor(Type::EmptyTypes));
    // 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.
    ctor0IL->Emit(OpCodes::Ldarg_0);
    ctor0IL->Emit(OpCodes::Ldc_I4_S, 42);
    ctor0IL->Emit(OpCodes::Stfld, fbNumber);
    ctor0IL->Emit(OpCodes::Ret);

    // Define a property named Number that gets and sets the private 
    // field.
    //
    // The last argument of DefineProperty is nullptr, because the
    // property has no parameters. (If you don't specify nullptr, 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, 
        int::typeid, 
        nullptr);
      
    // 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 nullptr could be 
    // used instead of Types::EmptyTypes)
    MethodBuilder^ mbNumberGetAccessor = tb->DefineMethod(
        "get_Number", 
        getSetAttr, 
        int::typeid, 
        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, 
        nullptr, 
        gcnew array<Type^> { int::typeid });
      
    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, 
        int::typeid, 
        gcnew array<Type^> { int::typeid });

    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 = Activator::CreateInstance(t);

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

    // 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.
    array<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 = Activator::CreateInstance(t, 
        gcnew array<Object^> { 5280 });
    Console::WriteLine("o2->Number: {0}", pi->GetValue(o2, nullptr));
};

/* This code produces the following output:

o1->Number: 42
o1->Number: 127
o1->MyMethod(22): 2794
o2->Number: 5280
 */
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

Aşağıdaki kod örneği, kullanarak TypeBuilderdinamik olarak bir türün nasıl derlenmiş olduğunu gösterir.

using namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
Type^ DynamicDotProductGen()
{
   Type^ ivType = nullptr;
   array<Type^>^temp0 = {int::typeid,int::typeid,int::typeid};
   array<Type^>^ctorParams = temp0;
   AppDomain^ myDomain = Thread::GetDomain();
   AssemblyName^ myAsmName = gcnew 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", int::typeid, FieldAttributes::Private );
   FieldBuilder^ yField = ivTypeBld->DefineField( "y", int::typeid, FieldAttributes::Private );
   FieldBuilder^ zField = ivTypeBld->DefineField( "z", int::typeid, FieldAttributes::Private );
   Type^ objType = Type::GetType( "System.Object" );
   ConstructorInfo^ objCtor = objType->GetConstructor( gcnew array<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.
   array<Type^>^temp1 = {ivTypeBld};
   array<Type^>^dpParams = temp1;
   
   // 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, int::typeid, 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;
}

int main()
{
   Type^ IVType = nullptr;
   Object^ aVector1 = nullptr;
   Object^ aVector2 = nullptr;
   array<Type^>^temp2 = {int::typeid,int::typeid,int::typeid};
   array<Type^>^aVtypes = temp2;
   array<Object^>^temp3 = {10,10,10};
   array<Object^>^aVargs1 = temp3;
   array<Object^>^temp4 = {20,20,20};
   array<Object^>^aVargs2 = temp4;
   
   // 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 );
   array<Object^>^passMe = gcnew array<Object^>(1);
   passMe[ 0 ] = dynamic_cast<Object^>(aVector2);
   Console::WriteLine( "(10, 10, 10) . (20, 20, 20) = {0}", IVType->InvokeMember( "DotProduct", BindingFlags::InvokeMethod, nullptr, aVector1, passMe ) );
}

// +++ OUTPUT +++
// ---
// (10, 10, 10) . (20, 20, 20) = 600
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

Açıklamalar

Bu API hakkında daha fazla bilgi için bkz . TypeBuilder için ek API açıklamaları.

Oluşturucular

TypeBuilder()

TypeBuilder sınıfının yeni bir örneğini başlatır.

Alanlar

UnspecifiedTypeSize

Türün toplam boyutunun belirtilmediğini temsil eder.

Özellikler

Assembly

Bu tür tanımını içeren dinamik derlemeyi alır.

AssemblyQualifiedName

Derlemenin görünen adıyla nitelenen bu türün tam adını döndürür.

Attributes

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

Attributes

ile Typeilişkili öznitelikleri alır.

(Devralındığı yer: Type)
Attributes

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
BaseType

Bu türün temel türünü alır.

ContainsGenericParameters

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

ContainsGenericParameters

Geçerli Type nesnenin belirli türler tarafından değiştirilmemiş tür parametrelerine sahip olup olmadığını gösteren bir değer alır.

(Devralındığı yer: Type)
ContainsGenericParameters

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
CustomAttributes

Bu üyenin özel özniteliklerini içeren bir koleksiyon alır.

(Devralındığı yer: MemberInfo)
DeclaredConstructors

Geçerli tür tarafından bildirilen oluşturucuların koleksiyonunu alır.

(Devralındığı yer: TypeInfo)
DeclaredEvents

Geçerli tür tarafından tanımlanan olayların koleksiyonunu alır.

(Devralındığı yer: TypeInfo)
DeclaredFields

Geçerli tür tarafından tanımlanan alanların koleksiyonunu alır.

(Devralındığı yer: TypeInfo)
DeclaredMembers

Geçerli tür tarafından tanımlanan üyelerin koleksiyonunu alır.

(Devralındığı yer: TypeInfo)
DeclaredMethods

Geçerli tür tarafından tanımlanan yöntemlerin koleksiyonunu alır.

(Devralındığı yer: TypeInfo)
DeclaredNestedTypes

Geçerli tür tarafından tanımlanan iç içe türlerin koleksiyonunu alır.

(Devralındığı yer: TypeInfo)
DeclaredProperties

Geçerli tür tarafından tanımlanan özelliklerin koleksiyonunu alır.

(Devralındığı yer: TypeInfo)
DeclaringMethod

Geçerli genel tür parametresini bildiren yöntemi alır.

DeclaringMethod

MethodBase GeçerliType, genel bir yöntemin tür parametresini temsil ederse bildirimde bulunan yöntemi temsil eden bir alır.

(Devralındığı yer: Type)
DeclaringType

Bu türü belirten türü döndürür.

FullName

Bu türün tam yolunu alır.

GenericParameterAttributes

Geçerli genel tür parametresinin kovaryansını ve özel kısıtlamalarını gösteren bir değer alır.

GenericParameterAttributes

Geçerli genel tür parametresinin GenericParameterAttributes kovaryansı ve özel kısıtlamalarını açıklayan bayrakların bir bileşimini alır.

(Devralındığı yer: Type)
GenericParameterPosition

Bir tür parametresinin, parametreyi bildiren genel türün tür parametre listesindeki konumunu alır.

GenericParameterPosition

Nesne genel tür veya genel bir yöntemin tür parametresini temsil ettiğinde Type , tür parametresinin, parametreyi bildiren genel türün veya yöntemin tür parametresi listesindeki konumunu alır.

(Devralındığı yer: Type)
GenericTypeArguments

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

GenericTypeArguments

Bu tür için genel tür bağımsız değişkenlerinden oluşan bir dizi alır.

(Devralındığı yer: Type)
GenericTypeArguments

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GenericTypeParameters

Geçerli örneğin genel tür parametrelerinin dizisini alır.

(Devralındığı yer: TypeInfo)
GUID

Bu türün GUID'sini alır.

HasElementType

Geçerli Type değerin başka bir türü kapsadığını veya başka bir türe başvurduğunu; yani geçerlinin Type bir dizi mi, işaretçi mi yoksa başvuruyla mı geçirildiğini belirten bir değer alır.

(Devralındığı yer: Type)
HasElementType

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
ImplementedInterfaces

Geçerli tür tarafından uygulanan arabirimlerin koleksiyonunu alır.

(Devralındığı yer: TypeInfo)
IsAbstract

soyut olup olmadığını Type ve geçersiz kılınması gerektiğini belirten bir değer alır.

(Devralındığı yer: Type)
IsAbstract

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsAnsiClass

için Typedize biçimi özniteliğinin AnsiClass seçili olup olmadığını belirten bir değer alır.

(Devralındığı yer: Type)
IsAnsiClass

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsArray

Türün bir dizi olup olmadığını belirten bir değer alır.

(Devralındığı yer: Type)
IsArray

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsAutoClass

için Typedize biçimi özniteliğinin AutoClass seçili olup olmadığını belirten bir değer alır.

(Devralındığı yer: Type)
IsAutoClass

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsAutoLayout

Geçerli türdeki alanların ortak dil çalışma zamanı tarafından otomatik olarak yerleştirilip yerleştirildiğini belirten bir değer alır.

(Devralındığı yer: Type)
IsAutoLayout

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsByRef

öğesinin başvuruyla geçirilip geçirilmediğini Type belirten bir değer alır.

(Devralındığı yer: Type)
IsByRef

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsByRefLike

Türün byref benzeri bir yapı olup olmadığını gösteren bir değer alır.

IsByRefLike

Türün byref benzeri bir yapı olup olmadığını gösteren bir değer alır.

(Devralındığı yer: Type)
IsClass

öğesinin Type bir sınıf mı yoksa temsilci mi olduğunu belirten bir değer alır; yani bir değer türü veya arabirimi değil.

(Devralındığı yer: Type)
IsClass

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsCollectible

Bu MemberInfo nesnenin bir collectible AssemblyLoadContextiçinde tutulan derlemenin parçası olup olmadığını gösteren bir değer alır.

(Devralındığı yer: MemberInfo)
IsCOMObject

öğesinin bir COM nesnesi olup olmadığını Type belirten bir değer alır.

(Devralındığı yer: Type)
IsCOMObject

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsConstructedGenericType

Bu nesnenin, bir genel tür oluşturup oluşturmadığını gösteren bir değer alır.

IsConstructedGenericType

Bu nesnenin, bir genel tür oluşturup oluşturmadığını gösteren bir değer alır. Oluşturulacak genel türün örneklerini oluşturabilirsiniz.

(Devralındığı yer: Type)
IsContextful

öğesinin bir bağlamda barındırılıp Type barındırılamayacağını belirten bir değer alır.

(Devralındığı yer: Type)
IsEnum

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

IsEnum

Geçerli Type değerin bir numaralandırmayı temsil edip etmediğini belirten bir değer alır.

(Devralındığı yer: Type)
IsEnum

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsExplicitLayout

Geçerli türdeki alanların açıkça belirtilen uzaklıklarda yerleştirilip yerleştirildiğini belirten bir değer alır.

(Devralındığı yer: Type)
IsExplicitLayout

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsFunctionPointer

Geçerlinin Type işlev işaretçisi olup olmadığını gösteren bir değer alır.

(Devralındığı yer: Type)
IsGenericMethodParameter

Geçerlinin Type genel bir yöntemin tanımında tür parametresini temsil edip etmediğini gösteren bir değer alır.

(Devralındığı yer: Type)
IsGenericParameter

Geçerli türün genel tür parametresi olup olmadığını belirten bir değer alır.

IsGenericParameter

Geçerli Type değerin genel bir tür veya yöntemin tanımındaki tür parametresini temsil edip etmediğini belirten bir değer alır.

(Devralındığı yer: Type)
IsGenericType

Geçerli türün genel bir tür olup olmadığını belirten bir değer alır.

IsGenericType

Geçerli türün genel bir tür olup olmadığını belirten bir değer alır.

(Devralındığı yer: Type)
IsGenericTypeDefinition

Geçerli TypeBuilder değerin, diğer genel türlerin oluşturulabileceği genel tür tanımını temsil edip etmediğini belirten bir değer alır.

IsGenericTypeDefinition

Geçerli Type değerin, diğer genel türlerin oluşturulabileceği genel tür tanımını temsil edip etmediğini belirten bir değer alır.

(Devralındığı yer: Type)
IsGenericTypeParameter

Geçerli Type değerin genel bir türün tanımında tür parametresini temsil edip etmediğini gösteren bir değer alır.

(Devralındığı yer: Type)
IsImport

öğesinin Type bir COM türü kitaplığından içeri aktarıldığını belirten bir ComImportAttribute özniteliğin uygulanıp uygulanmadığını belirten bir değer alır.

(Devralındığı yer: Type)
IsImport

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsInterface

öğesinin Type bir arabirim olup olmadığını belirten bir değer alır; bir sınıf veya değer türü değil.

(Devralındığı yer: Type)
IsInterface

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsLayoutSequential

Geçerli türün alanlarının meta verilerde tanımlandığı veya yayıldığı sırada sıralı olarak düzenlendiğini belirten bir değer alır.

(Devralındığı yer: Type)
IsLayoutSequential

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsMarshalByRef

öğesinin başvuruya göre sıralanıp sıralanmadığını Type belirten bir değer alır.

(Devralındığı yer: Type)
IsMarshalByRef

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsNested

Geçerli Type nesnenin, tanımı başka bir türün tanımı içinde iç içe yerleştirilmiş bir türü temsil edip etmediğini belirten bir değer alır.

(Devralındığı yer: Type)
IsNested

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsNestedAssembly

öğesinin iç içe olup olmadığını ve yalnızca kendi derlemesinde görünür olup olmadığını Type belirten bir değer alır.

(Devralındığı yer: Type)
IsNestedAssembly

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsNestedFamANDAssem

öğesinin iç içe olup olmadığını ve yalnızca hem kendi ailesine hem de kendi derlemesine ait sınıflara görünür olup olmadığını Type belirten bir değer alır.

(Devralındığı yer: Type)
IsNestedFamANDAssem

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsNestedFamily

öğesinin iç içe olup olmadığını ve yalnızca kendi ailesi içinde görünür olup olmadığını Type belirten bir değer alır.

(Devralındığı yer: Type)
IsNestedFamily

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsNestedFamORAssem

öğesinin iç içe olduğunu ve yalnızca kendi ailesine veya kendi derlemesine ait sınıflara görünür olduğunu Type belirten bir değer alır.

(Devralındığı yer: Type)
IsNestedFamORAssem

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsNestedPrivate

öğesinin iç içe ve özel olarak bildirilip bildirildiğini Type belirten bir değer alır.

(Devralındığı yer: Type)
IsNestedPrivate

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsNestedPublic

Bir sınıfın iç içe geçmiş ve genel olarak bildirilmiş olup olmadığını belirten bir değer alır.

(Devralındığı yer: Type)
IsNestedPublic

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsNotPublic

öğesinin genel olarak bildirilip Type bildirilmediğini belirten bir değer alır.

(Devralındığı yer: Type)
IsNotPublic

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsPointer

öğesinin işaretçi olup olmadığını Type belirten bir değer alır.

(Devralındığı yer: Type)
IsPointer

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsPrimitive

öğesinin ilkel türlerden biri olup olmadığını Type belirten bir değer alır.

(Devralındığı yer: Type)
IsPrimitive

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsPublic

öğesinin genel olarak bildirilip bildirildiğini Type belirten bir değer alır.

(Devralındığı yer: Type)
IsPublic

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsSealed

öğesinin korumalı olarak bildirilip bildirildiğini Type belirten bir değer alır.

(Devralındığı yer: Type)
IsSealed

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsSecurityCritical

Geçerli türün güvenlik açısından kritik mi yoksa güvenlik açısından güvenli mi olduğunu belirten bir değer alır ve bu nedenle kritik işlemler gerçekleştirebilir.

IsSecurityCritical

Geçerli türün geçerli güven düzeyinde güvenlik açısından kritik veya güvenlik açısından güvenli-kritik olup olmadığını belirten bir değer alır ve bu nedenle kritik işlemleri gerçekleştirebilir.

(Devralındığı yer: Type)
IsSecuritySafeCritical

Geçerli türün güvenlik açısından güvenli-kritik olup olmadığını gösteren bir değer alır; yani, kritik işlemler gerçekleştirip gerçekleştiremeyeceğini ve saydam kodla erişilip erişilemeyeceğini gösterir.

IsSecuritySafeCritical

Geçerli türün geçerli güven düzeyinde güvenlik açısından güvenli-kritik olup olmadığını belirten bir değer alır; yani, kritik işlemler gerçekleştirip gerçekleştiremeyeceği ve saydam kod tarafından erişilip erişilemeyeceği.

(Devralındığı yer: Type)
IsSecurityTransparent

Geçerli türün saydam olup olmadığını belirten bir değer alır ve bu nedenle kritik işlemler gerçekleştiremez.

IsSecurityTransparent

Geçerli türün geçerli güven düzeyinde saydam olup olmadığını belirten bir değer alır ve bu nedenle kritik işlemleri gerçekleştiremez.

(Devralındığı yer: Type)
IsSerializable

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

IsSerializable
Geçersiz.

ikili serileştirilebilir olup olmadığını Type belirten bir değer alır.

(Devralındığı yer: Type)
IsSerializable

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsSignatureType

Türün imza türü olup olmadığını gösteren bir değer alır.

(Devralındığı yer: Type)
IsSpecialName

Türün özel işleme gerektiren bir ada sahip olup olmadığını belirten bir değer alır.

(Devralındığı yer: Type)
IsSpecialName

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsSZArray

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

IsSZArray

Türün yalnızca sıfır alt sınıra sahip tek boyutlu bir diziyi temsil eden bir dizi türü olup olmadığını gösteren bir değer alır.

(Devralındığı yer: Type)
IsTypeDefinition

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

IsTypeDefinition

Türün tür tanımı olup olmadığını gösteren bir değer alır.

(Devralındığı yer: Type)
IsUnicodeClass

için Typedize biçimi özniteliğinin UnicodeClass seçili olup olmadığını belirten bir değer alır.

(Devralındığı yer: Type)
IsUnicodeClass

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsUnmanagedFunctionPointer

Geçerlinin Type yönetilmeyen bir işlev işaretçisi olup olmadığını gösteren bir değer alır.

(Devralındığı yer: Type)
IsValueType

değerinin bir değer türü olup olmadığını Type belirten bir değer alır.

(Devralındığı yer: Type)
IsValueType

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsVariableBoundArray

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

IsVariableBoundArray

Türün çok boyutlu bir diziyi mi yoksa rastgele alt sınıra sahip bir diziyi mi temsil ettiğini gösteren bir değer alır.

(Devralındığı yer: Type)
IsVisible

derleme dışındaki kod tarafından erişilip Type erişilemeyeceğini belirten bir değer alır.

(Devralındığı yer: Type)
IsVisible

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
MemberType

Bu üyenin bir MemberTypes tür veya iç içe bir tür olduğunu belirten bir değer alır.

(Devralındığı yer: Type)
MemberType

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
MetadataToken

Meta verilerdeki geçerli dinamik modülü tanımlayan bir belirteç alır.

MetadataToken

Meta veri öğesini tanımlayan bir değer alır.

(Devralındığı yer: MemberInfo)
Module

Bu tür tanımını içeren dinamik modülü alır.

Name

Bu türün adını alır.

Namespace

Bunun TypeBuilder tanımlandığı ad alanını alır.

PackingSize

Bu türün paketleme boyutunu alır.

PackingSizeCore

Türetilmiş bir sınıfta geçersiz kılındığında, bu türün paketleme boyutunu alır.

ReflectedType

Bu türü elde etmek için kullanılan türü döndürür.

ReflectedType

bu örneğini MemberInfoalmak için kullanılan sınıf nesnesini alır.

(Devralındığı yer: MemberInfo)
Size

Bir türün toplam boyutunu alır.

SizeCore

Türetilmiş bir sınıfta geçersiz kılındığında, türün toplam boyutunu alır.

StructLayoutAttribute

Geçerli türün düzenini açıklayan bir StructLayoutAttribute alır.

(Devralındığı yer: Type)
StructLayoutAttribute

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
TypeHandle

Dinamik modüllerde desteklenmez.

TypeInitializer

Türün başlatıcısını alır.

(Devralındığı yer: Type)
TypeInitializer

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
TypeToken

Bu türün tür belirtecini döndürür.

UnderlyingSystemType

Bu TypeBuilderiçin temel alınan sistem türünü döndürür.

UnderlyingSystemType

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)

Yöntemler

AddDeclarativeSecurity(SecurityAction, PermissionSet)

Bu türe bildirim temelli güvenlik ekler.

AddInterfaceImplementation(Type)

Bu türün uyguladığı bir arabirim ekler.

AddInterfaceImplementationCore(Type)

Türetilmiş bir sınıfta geçersiz kılındığında, bu türün uyguladığı bir arabirim ekler.

AsType()

Geçerli türü nesne Type olarak döndürür.

(Devralındığı yer: TypeInfo)
CreateType()

sınıfı için bir Type nesnesi oluşturur. sınıfında alanları ve yöntemleri tanımladıktan sonra, CreateType nesnesini yüklemek için çağrılır Type .

CreateTypeInfo()

Bu türü temsil eden bir TypeInfo nesne alır.

CreateTypeInfoCore()

Türetilmiş bir sınıfta geçersiz kılındığında, bu türü temsil eden bir TypeInfo nesne alır.

DefineConstructor(MethodAttributes, CallingConventions, Type[])

Belirtilen öznitelikler ve imza ile türüne yeni bir oluşturucu ekler.

DefineConstructor(MethodAttributes, CallingConventions, Type[], Type[][], Type[][])

Belirtilen öznitelikler, imza ve özel değiştiricilerle türüne yeni bir oluşturucu ekler.

DefineConstructorCore(MethodAttributes, CallingConventions, Type[], Type[][], Type[][])

Türetilmiş bir sınıfta geçersiz kılındığında, türüne verilen öznitelikler, imza ve özel değiştiricilerle yeni bir oluşturucu ekler.

DefineDefaultConstructor(MethodAttributes)

Parametresiz oluşturucuyu tanımlar. Burada tanımlanan oluşturucu yalnızca üst öğesinin parametresiz oluşturucuyu çağırır.

DefineDefaultConstructorCore(MethodAttributes)

Türetilmiş bir sınıfta geçersiz kılındığında parametresiz oluşturucuyu tanımlar. Burada tanımlanan oluşturucu, üst öğesinin parametresiz oluşturucusunu çağırır.

DefineEvent(String, EventAttributes, Type)

Türüne verilen ad, öznitelikler ve olay türüyle yeni bir olay ekler.

DefineEventCore(String, EventAttributes, Type)

Türetilmiş bir sınıfta geçersiz kılındığında, türüne verilen ad, öznitelikler ve olay türüyle yeni bir olay ekler.

DefineField(String, Type, FieldAttributes)

Türe, verilen ad, öznitelikler ve alan türüyle yeni bir alan ekler.

DefineField(String, Type, Type[], Type[], FieldAttributes)

Türe, verilen ad, öznitelikler, alan türü ve özel değiştiricilerle yeni bir alan ekler.

DefineFieldCore(String, Type, Type[], Type[], FieldAttributes)

Türetilmiş bir sınıfta geçersiz kılındığında, türe verilen ad, öznitelikler, alan türü ve özel değiştiricilerle yeni bir alan ekler.

DefineGenericParameters(String[])

Geçerli türün genel tür parametrelerini tanımlar, sayılarını ve adlarını belirtir ve kısıtlamalarını ayarlamak için kullanılabilecek bir nesne dizisi GenericTypeParameterBuilder döndürür.

DefineGenericParametersCore(String[])

Türetilmiş bir sınıfta geçersiz kılındığında, geçerli türün genel tür parametrelerini tanımlar ve bunların sayılarını ve adlarını belirtir.

DefineInitializedData(String, Byte[], FieldAttributes)

Taşınabilir yürütülebilir (PE) dosyasının .sdata bölümünde başlatılan veri alanını tanımlar.

DefineInitializedDataCore(String, Byte[], FieldAttributes)

Türetilmiş bir sınıfta geçersiz kılındığında, taşınabilir yürütülebilir (PE) dosyasının .sdata bölümünde başlatılan veri alanını tanımlar.

DefineMethod(String, MethodAttributes)

Belirtilen ad ve yöntem öznitelikleriyle türüne yeni bir yöntem ekler.

DefineMethod(String, MethodAttributes, CallingConventions)

Türüne belirtilen ada, yöntem özniteliklerine ve çağırma kuralına sahip yeni bir yöntem ekler.

DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[])

Belirtilen ad, yöntem öznitelikleri, çağırma kuralı ve yöntem imzası ile türüne yeni bir yöntem ekler.

DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])

Türüne belirtilen ad, yöntem öznitelikleri, çağırma kuralı, yöntem imzası ve özel değiştiricilerle yeni bir yöntem ekler.

DefineMethod(String, MethodAttributes, Type, Type[])

Türüne, belirtilen ad, yöntem öznitelikleri ve yöntem imzasıyla yeni bir yöntem ekler.

DefineMethodCore(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])

Türetilmiş bir sınıfta geçersiz kılındığında, türüne belirtilen ad, yöntem öznitelikleri, çağırma kuralı, yöntem imzası ve özel değiştiricilerle yeni bir yöntem ekler.

DefineMethodOverride(MethodInfo, MethodInfo)

Belirli bir yöntem bildirimini uygulayan ve farklı bir ada sahip olabilecek belirli bir yöntem gövdesini belirtir.

DefineMethodOverrideCore(MethodInfo, MethodInfo)

Türetilmiş bir sınıfta geçersiz kılındığında, belirli bir yöntem bildirimini uygulayan belirli bir yöntem gövdesini belirtir( farklı bir adla olabilir).

DefineNestedType(String)

adı verilen iç içe bir tür tanımlar.

DefineNestedType(String, TypeAttributes)

Adı ve öznitelikleri göz önünde bulundurularak iç içe bir tür tanımlar.

DefineNestedType(String, TypeAttributes, Type)

adı, öznitelikleri ve genişletilen türü göz önünde bulundurularak iç içe bir tür tanımlar.

DefineNestedType(String, TypeAttributes, Type, Int32)

adı, öznitelikleri, türün toplam boyutu ve genişletilen türü göz önünde bulundurarak iç içe bir tür tanımlar.

DefineNestedType(String, TypeAttributes, Type, PackingSize)

adı, öznitelikleri, genişletilen türü ve paketleme boyutu göz önünde bulundurularak iç içe bir tür tanımlar.

DefineNestedType(String, TypeAttributes, Type, PackingSize, Int32)

Adı, öznitelikleri, boyutu ve genişletilen türü göz önünde bulundurularak iç içe bir tür tanımlar.

DefineNestedType(String, TypeAttributes, Type, Type[])

adı, öznitelikleri, genişletilen türü ve uyguladığı arabirimleri göz önünde bulundurarak iç içe bir tür tanımlar.

DefineNestedTypeCore(String, TypeAttributes, Type, Type[], PackingSize, Int32)

Türetilmiş bir sınıfta geçersiz kılındığında, adı, öznitelikleri, boyutu ve genişlettiği türe göre iç içe bir tür tanımlar.

DefinePInvokeMethod(String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)

Adı, yöntemin tanımlandığı DLL'nin adı, yöntemin öznitelikleri, yöntemin çağırma kuralı, yöntemin dönüş türü, yöntemin parametrelerinin türleri ve PInvoke bayraklar verilen bir PInvoke yöntemi tanımlar.

DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)

Adı, yöntemin tanımlandığı DLL'nin adı, giriş noktasının adı, yöntemin öznitelikleri, yöntemin çağırma kuralı, yöntemin dönüş türü, yöntemin parametrelerinin türleri ve PInvoke bayraklar verilen bir PInvoke yöntemi tanımlar.

DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][], CallingConvention, CharSet)

Adı, yönteminin tanımlandığı DLL'nin adı, giriş noktasının adı, yöntemin öznitelikleri, yöntemin çağırma kuralı, yöntemin dönüş türü, yöntemin parametrelerinin türleri, PInvoke bayraklar ve parametreler ve dönüş türü için özel değiştiriciler verilen bir PInvoke yöntemi tanımlar.

DefinePInvokeMethodCore(String, String, String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][], CallingConvention, CharSet)

Türetilmiş bir sınıfta geçersiz kılındığında, sağlanan ad, DLL adı, giriş noktası adı, öznitelikler, çağırma kuralı, dönüş türü, parametre türleri, PInvoke bayrakları ve parametreler ve dönüş türü için özel değiştiriciler ile bir PInvoke yöntemi tanımlar.

DefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[])

Türüne verilen ad, öznitelikler, çağırma kuralı ve özellik imzası ile yeni bir özellik ekler.

DefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])

Türüne verilen ad, çağırma kuralı, özellik imzası ve özel değiştiricilerle yeni bir özellik ekler.

DefineProperty(String, PropertyAttributes, Type, Type[])

Türüne verilen ad ve özellik imzası ile yeni bir özellik ekler.

DefineProperty(String, PropertyAttributes, Type, Type[], Type[], Type[], Type[][], Type[][])

Türüne verilen ad, özellik imzası ve özel değiştiricilerle yeni bir özellik ekler.

DefinePropertyCore(String, PropertyAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])

Türetilmiş bir sınıfta geçersiz kılındığında, türe verilen ad, çağırma kuralı, özellik imzası ve özel değiştiricilerle yeni bir özellik ekler.

DefineTypeInitializer()

Bu tür için başlatıcıyı tanımlar.

DefineTypeInitializerCore()

Türetilmiş bir sınıfta geçersiz kılındığında, bu tür için başlatıcıyı tanımlar.

DefineUninitializedData(String, Int32, FieldAttributes)

Taşınabilir yürütülebilir (PE) dosyasının .sdata bölümünde başlatılmamış bir veri alanı tanımlar.

DefineUninitializedDataCore(String, Int32, FieldAttributes)

Türetilmiş bir sınıfta geçersiz kılındığında, taşınabilir yürütülebilir dosya (PE) dosyasının .sdata bölümünde başlatılmamış bir veri alanı tanımlar.

Equals(Object)

Geçerli Type nesnenin temel sistem türünün belirtilen Objecttemel sistem türüyle aynı olup olmadığını belirler.

(Devralındığı yer: Type)
Equals(Object)

Bu örneğin belirtilen bir nesneye eşit olup olmadığını gösteren bir değeri döndürür.

(Devralındığı yer: MemberInfo)
Equals(Type)

Geçerlinin Type temel sistem türünün belirtilen Typetemel sistem türüyle aynı olup olmadığını belirler.

(Devralındığı yer: Type)
FindInterfaces(TypeFilter, Object)

Geçerli Typetarafından uygulanan veya devralınan arabirimlerin filtrelenmiş listesini temsil eden bir nesne dizisi Type döndürür.

(Devralındığı yer: Type)
FindInterfaces(TypeFilter, Object)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)

Belirtilen üye türündeki MemberInfo nesnelerin filtrelenmiş bir dizisini döndürür.

(Devralındığı yer: Type)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetArrayRank()

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

GetArrayRank()

Dizideki boyut sayısını alır.

(Devralındığı yer: Type)
GetArrayRank()

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetAttributeFlagsImpl()

Türetilmiş bir sınıfta geçersiz kılındığında, özelliğini uygular Attributes ve ile ilişkili öznitelikleri gösteren sabit listesi değerlerinin bit düzeyinde bir bileşimini Typealır.

GetAttributeFlagsImpl()

Türetilmiş bir sınıfta geçersiz kılındığında, özelliğini uygular Attributes ve ile ilişkili öznitelikleri gösteren sabit listesi değerlerinin bit düzeyinde bir bileşimini Typealır.

(Devralındığı yer: Type)
GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Belirtilen bağlama kısıtlamalarını ve belirtilen çağırma kuralını kullanarak, parametreleri belirtilen bağımsız değişken türleri ve değiştiricileriyle eşleşen bir oluşturucu arar.

(Devralındığı yer: Type)
GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])

Belirtilen bağlama kısıtlamalarını kullanarak parametreleri belirtilen bağımsız değişken türleri ve değiştiricilerle eşleşen bir oluşturucu arar.

(Devralındığı yer: Type)
GetConstructor(BindingFlags, Type[])

Belirtilen bağlama kısıtlamalarını kullanarak parametreleri belirtilen bağımsız değişken türleriyle eşleşen bir oluşturucu arar.

(Devralındığı yer: Type)
GetConstructor(Type, ConstructorInfo)

Belirtilen genel tür tanımının belirtilen oluşturucusunun karşılık gelen, belirtilen genel türün oluşturucusunu döndürür.

GetConstructor(Type[])

Parametreleri belirtilen dizideki türlerle eşleşen bir genel örnek oluşturucu arar.

(Devralındığı yer: Type)
GetConstructor(Type[])

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen bağlama kısıtlamalarını ve belirtilen çağırma kuralını kullanarak parametreleri belirtilen bağımsız değişken türleri ve değiştiricilerle eşleşen bir oluşturucu arar.

GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen bağlama kısıtlamalarını ve belirtilen çağırma kuralını kullanarak parametreleri belirtilen bağımsız değişken türleri ve değiştiricilerle eşleşen bir oluşturucu arar.

(Devralındığı yer: Type)
GetConstructors()

Geçerli Typeiçin tanımlanan tüm ortak oluşturucuları döndürür.

(Devralındığı yer: Type)
GetConstructors()

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetConstructors(BindingFlags)

Belirtilen şekilde, bu sınıf için tanımlanan genel ve genel olmayan oluşturucuları temsil eden bir nesne dizisi ConstructorInfo döndürür.

GetConstructors(BindingFlags)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetCustomAttributes(Boolean)

Bu tür için tanımlanan tüm özel öznitelikleri döndürür.

GetCustomAttributes(Boolean)

Türetilmiş bir sınıfta geçersiz kılındığında, bu üyeye uygulanan tüm özel özniteliklerden oluşan bir dizi döndürür.

(Devralındığı yer: MemberInfo)
GetCustomAttributes(Type, Boolean)

Geçerli türün belirtilen türe atanabilen tüm özel özniteliklerini döndürür.

GetCustomAttributes(Type, Boolean)

Türetilmiş bir sınıfta geçersiz kılındığında, bu üyeye uygulanan ve tarafından Typetanımlanan bir özel öznitelik dizisi döndürür.

(Devralındığı yer: MemberInfo)
GetCustomAttributesData()

Hedef üyeye CustomAttributeData uygulanmış özniteliklerle ilgili verileri temsil eden nesnelerin listesini döndürür.

(Devralındığı yer: MemberInfo)
GetDeclaredEvent(String)

Geçerli tür tarafından bildirilen belirtilen olayı temsil eden bir nesne döndürür.

(Devralındığı yer: TypeInfo)
GetDeclaredField(String)

Geçerli tür tarafından bildirilen belirtilen alanı temsil eden bir nesne döndürür.

(Devralındığı yer: TypeInfo)
GetDeclaredMethod(String)

Geçerli tür tarafından bildirilen belirtilen yöntemi temsil eden bir nesne döndürür.

(Devralındığı yer: TypeInfo)
GetDeclaredMethods(String)

Belirtilen adla eşleşen geçerli tür üzerinde bildirilen tüm yöntemleri içeren bir koleksiyon döndürür.

(Devralındığı yer: TypeInfo)
GetDeclaredNestedType(String)

Geçerli tür tarafından bildirilen belirtilen iç içe türü temsil eden bir nesne döndürür.

(Devralındığı yer: TypeInfo)
GetDeclaredProperty(String)

Geçerli tür tarafından bildirilen belirtilen özelliği temsil eden bir nesne döndürür.

(Devralındığı yer: TypeInfo)
GetDefaultMembers()

Ayarlanmış olan geçerli TypeDefaultMemberAttribute için tanımlanan üyeleri arar.

(Devralındığı yer: Type)
GetDefaultMembers()

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetElementType()

Bu yöntemin çağrılması her zaman oluşturur NotSupportedException.

GetEnumName(Object)

Geçerli numaralandırma türü için belirtilen değere sahip sabitin adını döndürür.

(Devralındığı yer: Type)
GetEnumName(Object)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetEnumNames()

Geçerli sabit listesi türünün üyelerinin adlarını döndürür.

(Devralındığı yer: Type)
GetEnumNames()

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetEnumUnderlyingType()

Geçerli sabit listesi türünün temel türünü döndürür.

(Devralındığı yer: Type)
GetEnumUnderlyingType()

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetEnumValues()

Geçerli sabit listesi türündeki sabitlerin değerlerini içeren bir dizi döndürür.

(Devralındığı yer: Type)
GetEnumValues()

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetEnumValuesAsUnderlyingType()

Bu numaralandırma türünün temel tür sabitlerinin değerlerinin dizisini alır.

(Devralındığı yer: Type)
GetEvent(String)

EventInfo Belirtilen genel olayı temsil eden nesneyi döndürür.

(Devralındığı yer: Type)
GetEvent(String)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetEvent(String, BindingFlags)

Belirtilen ada sahip olayı döndürür.

GetEvent(String, BindingFlags)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetEvents()

Bu tür tarafından bildirilen veya devralınan genel olayları döndürür.

GetEvents()

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetEvents(BindingFlags)

Bu tür tarafından bildirilen genel ve genel olmayan olayları döndürür.

GetEvents(BindingFlags)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetField(String)

Belirtilen ada sahip ortak alanı arar.

(Devralındığı yer: Type)
GetField(String)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetField(String, BindingFlags)

Verilen adla belirtilen alanı döndürür.

GetField(String, BindingFlags)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetField(Type, FieldInfo)

Belirtilen oluşturulan genel türün, genel tür tanımının belirtilen alanına karşılık gelen alanını döndürür.

GetFields()

Geçerli Typeöğesinin tüm ortak alanlarını döndürür.

(Devralındığı yer: Type)
GetFields()

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetFields(BindingFlags)

Bu tür tarafından bildirilen genel ve ortak olmayan alanları döndürür.

GetFields(BindingFlags)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetFunctionPointerCallingConventions()

Türetilmiş bir sınıfta geçersiz kılındığında, geçerli işlev işaretçisinin Typeçağırma kurallarını döndürür.

(Devralındığı yer: Type)
GetFunctionPointerParameterTypes()

Türetilmiş bir sınıfta geçersiz kılındığında, geçerli işlev işaretçisinin Typeparametre türlerini döndürür.

(Devralındığı yer: Type)
GetFunctionPointerReturnType()

Türetilmiş bir sınıfta geçersiz kılındığında, geçerli işlev işaretçisinin Typedönüş türünü döndürür.

(Devralındığı yer: Type)
GetGenericArguments()

Genel bir türün Type tür bağımsız değişkenlerini veya genel tür tanımının tür parametrelerini temsil eden bir nesne dizisi döndürür.

GetGenericArguments()

Kapalı bir genel türün Type tür bağımsız değişkenlerini veya genel tür tanımının tür parametrelerini temsil eden bir nesne dizisi döndürür.

(Devralındığı yer: Type)
GetGenericArguments()

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetGenericParameterConstraints()

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

GetGenericParameterConstraints()

Geçerli genel tür parametresindeki kısıtlamaları temsil eden bir nesne dizisi Type döndürür.

(Devralındığı yer: Type)
GetGenericParameterConstraints()

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetGenericTypeDefinition()

Type Geçerli türün alınabileceği genel tür tanımını temsil eden bir nesne döndürür.

GetGenericTypeDefinition()

Geçerli genel türün oluşturulabileceği genel tür tanımını temsil eden bir Type nesne döndürür.

(Devralındığı yer: Type)
GetHashCode()

Bu örneğe ilişkin karma kodu döndürür.

(Devralındığı yer: Type)
GetHashCode()

Bu örneğe ilişkin karma kodu döndürür.

(Devralındığı yer: MemberInfo)
GetInterface(String)

Belirtilen ada sahip arabirimi arar.

(Devralındığı yer: Type)
GetInterface(String)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetInterface(String, Boolean)

Bu sınıf tarafından uygulanan arabirimi (doğrudan veya dolaylı olarak) ve verilen arabirim adıyla eşleşen tam adı döndürür.

GetInterface(String, Boolean)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetInterfaceMap(Type)

İstenen arabirim için bir arabirim eşlemesi döndürür.

GetInterfaces()

Bu tür ve temel türleri üzerinde uygulanan tüm arabirimlerden oluşan bir dizi döndürür.

GetInterfaces()

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetMember(String)

Belirtilen ada sahip genel üyeleri arar.

(Devralındığı yer: Type)
GetMember(String)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetMember(String, BindingFlags)

Belirtilen bağlama kısıtlamalarını kullanarak belirtilen üyeleri arar.

(Devralındığı yer: Type)
GetMember(String, BindingFlags)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetMember(String, MemberTypes, BindingFlags)

Belirtilen şekilde, bu tür tarafından bildirilen veya devralınan tüm genel ve genel olmayan üyeleri döndürür.

GetMember(String, MemberTypes, BindingFlags)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetMembers()

Geçerli Typeöğesinin tüm genel üyelerini döndürür.

(Devralındığı yer: Type)
GetMembers()

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetMembers(BindingFlags)

Bu tür tarafından bildirilen veya devralınan genel ve genel olmayan üyelerin üyelerini döndürür.

GetMembers(BindingFlags)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetMemberWithSameMetadataDefinitionAs(MemberInfo)

Belirtilen MemberInfoile MemberInfo eşleşen geçerli Type üzerinde öğesini arar.

(Devralındığı yer: Type)
GetMethod(String)

Belirtilen ada sahip public yöntemini arar.

(Devralındığı yer: Type)
GetMethod(String)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetMethod(String, BindingFlags)

Belirtilen bağlama kısıtlamalarını kullanarak belirtilen yöntemi arar.

(Devralındığı yer: Type)
GetMethod(String, BindingFlags)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Belirtilen bağlama kısıtlamalarını ve belirtilen çağırma kuralını kullanarak parametreleri belirtilen bağımsız değişken türleri ve değiştiricilerle eşleşen belirtilen yöntemi arar.

(Devralındığı yer: Type)
GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])

Belirtilen bağlama kısıtlamalarını kullanarak parametreleri belirtilen bağımsız değişken türleri ve değiştiricilerle eşleşen belirtilen yöntemi arar.

(Devralındığı yer: Type)
GetMethod(String, BindingFlags, Type[])

Belirtilen bağlama kısıtlamalarını kullanarak parametreleri belirtilen bağımsız değişken türleriyle eşleşen belirtilen yöntemi arar.

(Devralındığı yer: Type)
GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Belirtilen bağlama kısıtlamalarını ve belirtilen çağırma kuralını kullanarak parametreleri belirtilen genel parametre sayısıyla, bağımsız değişken türleriyle ve değiştiricilerle eşleşen belirtilen yöntemi arar.

(Devralındığı yer: Type)
GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[])

Belirtilen bağlama kısıtlamalarını kullanarak parametreleri belirtilen genel parametre sayısıyla, bağımsız değişken türleriyle ve değiştiricilerle eşleşen belirtilen yöntemi arar.

(Devralındığı yer: Type)
GetMethod(String, Int32, BindingFlags, Type[])

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: Type)
GetMethod(String, Int32, Type[])

Parametreleri belirtilen genel parametre sayısı ve bağımsız değişken türleriyle eşleşen belirtilen ortak yöntemi arar.

(Devralındığı yer: Type)
GetMethod(String, Int32, Type[], ParameterModifier[])

Parametreleri belirtilen genel parametre sayısı, bağımsız değişken türleri ve değiştiricilerle eşleşen belirtilen ortak yöntemi arar.

(Devralındığı yer: Type)
GetMethod(String, Type[])

Parametreleri belirtilen bağımsız değişken türleriyle eşleşen belirtilen ortak yöntemi arar.

(Devralındığı yer: Type)
GetMethod(String, Type[])

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetMethod(String, Type[], ParameterModifier[])

Parametreleri belirtilen bağımsız değişken türleri ve değiştiricileriyle eşleşen belirtilen ortak yöntemi arar.

(Devralındığı yer: Type)
GetMethod(String, Type[], ParameterModifier[])

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetMethod(Type, MethodInfo)

Belirtilen genel tür tanımının belirtilen yöntemine karşılık gelen, belirtilen genel türün yöntemini döndürür.

GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen bağlama kısıtlamalarını ve belirtilen çağırma kuralını kullanarak parametreleri belirtilen bağımsız değişken türleri ve değiştiricileriyle eşleşen belirtilen yöntemi arar.

GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen bağlama kısıtlamalarını ve belirtilen çağırma kuralını kullanarak parametreleri belirtilen bağımsız değişken türleri ve değiştiricileriyle eşleşen belirtilen yöntemi arar.

(Devralındığı yer: Type)
GetMethodImpl(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen bağlama kısıtlamalarını ve belirtilen çağırma kuralını kullanarak parametreleri belirtilen genel parametre sayısı, bağımsız değişken türleri ve değiştiricilerle eşleşen belirtilen yöntemi arar.

(Devralındığı yer: Type)
GetMethods()

Geçerli Typeöğesinin tüm genel yöntemlerini döndürür.

(Devralındığı yer: Type)
GetMethods()

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetMethods(BindingFlags)

Belirtilen şekilde, bu tür tarafından bildirilen veya devralınan tüm genel ve genel olmayan yöntemleri döndürür.

GetMethods(BindingFlags)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetNestedType(String)

Belirtilen ada sahip ortak iç içe türü arar.

(Devralındığı yer: Type)
GetNestedType(String)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetNestedType(String, BindingFlags)

Bu tür tarafından bildirilen genel ve genel olmayan iç içe türleri döndürür.

GetNestedType(String, BindingFlags)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetNestedTypes()

Geçerli Typeiçinde iç içe yerleştirilmiş genel türleri döndürür.

(Devralındığı yer: Type)
GetNestedTypes()

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetNestedTypes(BindingFlags)

Bu tür tarafından bildirilen veya devralınan genel ve genel olmayan iç içe türleri döndürür.

GetNestedTypes(BindingFlags)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetOptionalCustomModifiers()

Türetilmiş bir sınıfta geçersiz kılındığında, geçerli Typeöğesinin isteğe bağlı özel değiştiricilerini döndürür.

(Devralındığı yer: Type)
GetProperties()

Geçerli Typeöğesinin tüm genel özelliklerini döndürür.

(Devralındığı yer: Type)
GetProperties()

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetProperties(BindingFlags)

Belirtilen şekilde, bu tür tarafından bildirilen veya devralınan tüm genel ve genel olmayan özellikleri döndürür.

GetProperties(BindingFlags)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetProperty(String)

Belirtilen ada sahip ortak özelliği arar.

(Devralındığı yer: Type)
GetProperty(String)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetProperty(String, BindingFlags)

Belirtilen bağlama kısıtlamalarını kullanarak belirtilen özelliği arar.

(Devralındığı yer: Type)
GetProperty(String, BindingFlags)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])

Belirtilen bağlama kısıtlamalarını kullanarak parametreleri belirtilen bağımsız değişken türleri ve değiştiricileriyle eşleşen belirtilen özelliği arar.

(Devralındığı yer: Type)
GetProperty(String, Type)

Belirtilen ada ve dönüş türüne sahip ortak özelliği arar.

(Devralındığı yer: Type)
GetProperty(String, Type)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetProperty(String, Type, Type[])

Parametreleri belirtilen bağımsız değişken türleriyle eşleşen belirtilen ortak özelliği arar.

(Devralındığı yer: Type)
GetProperty(String, Type, Type[])

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetProperty(String, Type, Type[], ParameterModifier[])

Parametreleri belirtilen bağımsız değişken türleri ve değiştiricileriyle eşleşen belirtilen ortak özelliği arar.

(Devralındığı yer: Type)
GetProperty(String, Type, Type[], ParameterModifier[])

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetProperty(String, Type[])

Parametreleri belirtilen bağımsız değişken türleriyle eşleşen belirtilen ortak özelliği arar.

(Devralındığı yer: Type)
GetProperty(String, Type[])

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])

Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen bağlama kısıtlamalarını kullanarak parametreleri belirtilen bağımsız değişken türleri ve değiştiricileriyle eşleşen belirtilen özelliği arar.

GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])

Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen bağlama kısıtlamalarını kullanarak parametreleri belirtilen bağımsız değişken türleri ve değiştiricileriyle eşleşen belirtilen özelliği arar.

(Devralındığı yer: Type)
GetRequiredCustomModifiers()

Türetilmiş bir sınıfta geçersiz kılındığında, geçerli Typeöğesinin gerekli özel değiştiricilerini döndürür.

(Devralındığı yer: Type)
GetType()

Geçerli Typeöğesini alır.

(Devralındığı yer: Type)
GetType()

Bir üyenin özniteliklerini bulur ve üye meta verilerine erişim sağlar.

(Devralındığı yer: MemberInfo)
GetTypeCodeImpl()

Bu Type örneğin temel alınan tür kodunu döndürür.

(Devralındığı yer: Type)
HasElementTypeImpl()

Türetilmiş bir sınıfta geçersiz kılındığında, özelliğini uygular HasElementType ve geçerlinin Type başka bir türü mü kapsadığını veya başvurduğunu belirler; yani, geçerlinin Type bir dizi mi, işaretçi mi yoksa başvuruyla mı geçirildiğini belirler.

HasElementTypeImpl()

Türetilmiş bir sınıfta geçersiz kılındığında, özelliğini uygular HasElementType ve geçerlinin Type başka bir türü mü kapsadığını veya başvurduğunu belirler; yani, geçerlinin Type bir dizi mi, işaretçi mi yoksa başvuruyla mı geçirildiğini belirler.

(Devralındığı yer: Type)
HasSameMetadataDefinitionAs(MemberInfo)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: MemberInfo)
InvokeMember(String, BindingFlags, Binder, Object, Object[])

Belirtilen bağlama kısıtlamalarını kullanarak ve belirtilen bağımsız değişken listesiyle eşleşen belirtilen üyeyi çağırır.

(Devralındığı yer: Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)

Belirtilen bağlama kısıtlamalarını kullanarak ve belirtilen bağımsız değişken listesi ve kültürüyle eşleşen belirtilen üyeyi çağırır.

(Devralındığı yer: Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])

Belirtilen üyeyi çağırır. Çağrılacak yöntemin erişilebilir olması ve belirtilen bağlayıcı ve çağırma özniteliklerinin kısıtlamaları altında belirtilen bağımsız değişken listesiyle en özel eşleşmeyi sağlaması gerekir.

IsArrayImpl()

Türetilmiş bir sınıfta geçersiz kılındığında, özelliğini uygular ve öğesinin IsArrayType bir dizi olup olmadığını belirler.

IsArrayImpl()

Türetilmiş bir sınıfta geçersiz kılındığında, özelliğini uygular ve öğesinin IsArrayType bir dizi olup olmadığını belirler.

(Devralındığı yer: Type)
IsAssignableFrom(Type)

Belirtilen Type bir nesnenin bu nesneye atanıp atanamayacağını belirten bir değer alır.

IsAssignableFrom(Type)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsAssignableFrom(TypeInfo)

Belirtilen TypeInfo bir nesnenin bu nesneye atanıp atanamayacağını gösteren bir değer alır.

IsAssignableTo(Type)

Geçerli türün belirtilen targetTypedeğişkenine atanıp atanamayacağını belirler.

(Devralındığı yer: Type)
IsByRefImpl()

Türetilmiş bir sınıfta geçersiz kılındığında, özelliğini uygular IsByRef ve başvurusu tarafından geçirilip geçirilmediğini Type belirler.

IsByRefImpl()

Türetilmiş bir sınıfta geçersiz kılındığında, özelliğini uygular IsByRef ve başvurusu tarafından geçirilip geçirilmediğini Type belirler.

(Devralındığı yer: Type)
IsCOMObjectImpl()

Türetilmiş bir sınıfta geçersiz kılındığında, özelliğini uygular ve öğesinin IsCOMObjectType bir COM nesnesi olup olmadığını belirler.

IsCOMObjectImpl()

Türetilmiş bir sınıfta geçersiz kılındığında, özelliğini uygular ve öğesinin IsCOMObjectType bir COM nesnesi olup olmadığını belirler.

(Devralındığı yer: Type)
IsContextfulImpl()

özelliğini uygular ve öğesinin IsContextful bir bağlamda barındırılıp Type barındırılamayacağını belirler.

(Devralındığı yer: Type)
IsCreated()

Geçerli dinamik türün oluşturulup oluşturulmadığını gösteren bir değer döndürür.

IsCreatedCore()

Türetilmiş bir sınıfta geçersiz kılındığında, geçerli dinamik türün oluşturulup oluşturulmadığını gösteren bir değer döndürür.

IsDefined(Type, Boolean)

Geçerli türe özel bir öznitelik uygulanıp uygulanmadığını belirler.

IsDefined(Type, Boolean)

Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen türde veya türetilmiş türlerinden bir veya daha fazla özniteliğin bu üyeye uygulanıp uygulanmadığını gösterir.

(Devralındığı yer: MemberInfo)
IsEnumDefined(Object)

Belirtilen değerin geçerli sabit listesi türünde var olup olmadığını belirten bir değer döndürür.

(Devralındığı yer: Type)
IsEnumDefined(Object)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsEquivalentTo(Type)

İki COM türünün aynı kimliğe sahip olup olmadığını ve tür eşdeğerliği için uygun olup olmadığını belirler.

(Devralındığı yer: Type)
IsEquivalentTo(Type)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsInstanceOfType(Object)

Belirtilen nesnenin geçerli Typeöğesinin bir örneği olup olmadığını belirler.

(Devralındığı yer: Type)
IsInstanceOfType(Object)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsMarshalByRefImpl()

özelliğini uygular ve öğesinin IsMarshalByRefType başvuruya göre sıralanıp sıralı olmadığını belirler.

(Devralındığı yer: Type)
IsPointerImpl()

Türetilmiş bir sınıfta geçersiz kılındığında, özelliğini uygular ve öğesinin IsPointerType bir işaretçi olup olmadığını belirler.

IsPointerImpl()

Türetilmiş bir sınıfta geçersiz kılındığında, özelliğini uygular IsPointer ve işaretçi olup olmadığını Type belirler.

(Devralındığı yer: Type)
IsPrimitiveImpl()

Türetilmiş bir sınıfta geçersiz kılındığında, özelliğini uygular IsPrimitive ve öğesinin ilkel türlerden biri olup olmadığını Type belirler.

IsPrimitiveImpl()

Türetilmiş bir sınıfta geçersiz kılındığında, özelliğini uygular IsPrimitive ve öğesinin ilkel türlerden biri olup olmadığını Type belirler.

(Devralındığı yer: Type)
IsSubclassOf(Type)

Bu türün belirtilen türden türetilip türetilmez olduğunu belirler.

IsSubclassOf(Type)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

(Devralındığı yer: TypeInfo)
IsValueTypeImpl()

özelliğini uygular ve değerinin IsValueTypeType bir değer türü olup olmadığını belirler; bir sınıf veya arabirim değil.

(Devralındığı yer: Type)
MakeArrayType()

Type Alt sınırı sıfır olan geçerli türün tek boyutlu dizisini temsil eden bir nesne döndürür.

MakeArrayType()

Type Geçerli türün bir boyutlu dizisini, alt sınırı sıfır olan bir nesneyi döndürür.

(Devralındığı yer: Type)
MakeArrayType(Int32)

Type Belirtilen sayıda boyutla geçerli türdeki bir diziyi temsil eden bir nesne döndürür.

MakeArrayType(Int32)

Type Belirtilen boyut sayısıyla geçerli türdeki bir diziyi temsil eden bir nesne döndürür.

(Devralındığı yer: Type)
MakeByRefType()

Type ParametreByRef (Visual Basic'te) olarak geçirildiğinde geçerli türü temsil eden bir ref nesne döndürür.

MakeByRefType()

Type Parametre (ByRefVisual Basic'te parametre) olarak geçirildiğinde geçerli türü temsil eden bir ref nesne döndürür.

(Devralındığı yer: Type)
MakeGenericType(Type[])

Geçerli genel tür tanımının tür parametreleri için bir tür dizisinin öğelerinin yerini alır ve sonuçta elde edilen türü döndürür.

MakeGenericType(Type[])

Geçerli genel tür tanımının tür parametreleri için bir tür dizisinin öğelerinin yerini alır ve sonuçta elde edilen türü temsil eden bir Type nesne döndürür.

(Devralındığı yer: Type)
MakePointerType()

Type Geçerli türe yönelik yönetilmeyen işaretçinin türünü temsil eden bir nesne döndürür.

MakePointerType()

Type Geçerli türün işaretçisini temsil eden bir nesne döndürür.

(Devralındığı yer: Type)
MemberwiseClone()

Geçerli Objectöğesinin sığ bir kopyasını oluşturur.

(Devralındığı yer: Object)
SetCustomAttribute(ConstructorInfo, Byte[])

Belirtilen özel öznitelik blobu kullanarak özel bir öznitelik ayarlar.

SetCustomAttribute(CustomAttributeBuilder)

Özel öznitelik oluşturucu kullanarak özel bir öznitelik ayarlayın.

SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)

Türetilmiş bir sınıfta geçersiz kılındığında, bu derlemede özel bir öznitelik ayarlar.

SetParent(Type)

Şu anda yapım aşamasında olan türün temel türünü ayarlar.

SetParentCore(Type)

Türetilmiş bir sınıfta geçersiz kılındığında, şu anda yapım aşamasında olan türün temel türünü ayarlar.

ToString()

Ad alanı dışında türün adını döndürür.

Belirtik Arabirim Kullanımları

_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Bir ad kümesini karşılık gelen bir dağıtma tanımlayıcısı kümesine eşler.

(Devralındığı yer: MemberInfo)
_MemberInfo.GetType()

Sınıfını temsil eden MemberInfo bir Type nesnesi alır.

(Devralındığı yer: MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Bir nesne için tür bilgilerini alır ve bu da bir arabirimin tür bilgisini almak için kullanılabilir.

(Devralındığı yer: MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

Bir nesnenin sağladığı tür bilgisi arabirimlerinin sayısını alır (0 ya da 1).

(Devralındığı yer: MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Bir nesne tarafından sunulan özelliklere ve yöntemlere erişim sağlar.

(Devralındığı yer: MemberInfo)
_Type.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Bir ad kümesini karşılık gelen bir dağıtma tanımlayıcısı kümesine eşler.

(Devralındığı yer: Type)
_Type.GetTypeInfo(UInt32, UInt32, IntPtr)

Bir nesne için tür bilgilerini alır ve bu da bir arabirimin tür bilgisini almak için kullanılabilir.

(Devralındığı yer: Type)
_Type.GetTypeInfoCount(UInt32)

Bir nesnenin sağladığı tür bilgisi arabirimlerinin sayısını alır (0 ya da 1).

(Devralındığı yer: Type)
_Type.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Bir nesne tarafından sunulan özelliklere ve yöntemlere erişim sağlar.

(Devralındığı yer: Type)
_TypeBuilder.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Bir ad kümesini karşılık gelen bir dağıtma tanımlayıcısı kümesine eşler.

_TypeBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)

Bir nesne için tür bilgilerini alır ve bu da bir arabirimin tür bilgisini almak için kullanılabilir.

_TypeBuilder.GetTypeInfoCount(UInt32)

Bir nesnenin sağladığı tür bilgisi arabirimlerinin sayısını alır (0 ya da 1).

_TypeBuilder.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Bir nesne tarafından sunulan özelliklere ve yöntemlere erişim sağlar.

ICustomAttributeProvider.GetCustomAttributes(Boolean)

Adlandırılmış öznitelikler hariç, bu üyede tanımlanan tüm özel özniteliklerin dizisini veya özel öznitelikler yoksa boş bir dizi döndürür.

(Devralındığı yer: MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)

Bu üyede tanımlanan, türe göre tanımlanan özel öznitelik dizisini veya bu türe ait özel öznitelikler yoksa boş bir dizi döndürür.

(Devralındığı yer: MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean)

Bir veya daha fazla örneğinin bu üyede tanımlanıp tanımlanmadığını attributeType gösterir.

(Devralındığı yer: MemberInfo)
IReflectableType.GetTypeInfo()

Geçerli türün bir gösterimini nesne TypeInfo olarak döndürür.

(Devralındığı yer: TypeInfo)

Uzantı Metotları

GetCustomAttribute(MemberInfo, Type)

Belirtilen üyeye uygulanan belirtilen türde bir özel özniteliği alır.

GetCustomAttribute(MemberInfo, Type, Boolean)

Belirtilen üyeye uygulanan belirtilen türde bir özel özniteliği alır ve isteğe bağlı olarak bu üyenin üstlerini inceler.

GetCustomAttribute<T>(MemberInfo)

Belirtilen üyeye uygulanan belirtilen türde bir özel özniteliği alır.

GetCustomAttribute<T>(MemberInfo, Boolean)

Belirtilen üyeye uygulanan belirtilen türde bir özel özniteliği alır ve isteğe bağlı olarak bu üyenin üstlerini inceler.

GetCustomAttributes(MemberInfo)

Belirtilen üyeye uygulanan özel öznitelikler koleksiyonunu alır.

GetCustomAttributes(MemberInfo, Boolean)

Belirtilen üyeye uygulanan özel özniteliklerden oluşan bir koleksiyonu alır ve isteğe bağlı olarak bu üyenin atalarını inceler.

GetCustomAttributes(MemberInfo, Type)

Belirtilen bir üyeye uygulanan belirtilen türde özel özniteliklerden oluşan bir koleksiyonu alır.

GetCustomAttributes(MemberInfo, Type, Boolean)

Belirtilen bir üyeye uygulanan belirtilen türde özel özniteliklerden oluşan bir koleksiyonu alır ve isteğe bağlı olarak bu üyenin üstlerini inceler.

GetCustomAttributes<T>(MemberInfo)

Belirtilen bir üyeye uygulanan belirtilen türde özel özniteliklerden oluşan bir koleksiyonu alır.

GetCustomAttributes<T>(MemberInfo, Boolean)

Belirtilen bir üyeye uygulanan belirtilen türde özel özniteliklerden oluşan bir koleksiyonu alır ve isteğe bağlı olarak bu üyenin üstlerini inceler.

IsDefined(MemberInfo, Type)

Belirtilen türde özel özniteliklerin belirtilen üyeye uygulanıp uygulanmadığını gösterir.

IsDefined(MemberInfo, Type, Boolean)

Belirtilen türlerdeki özel özniteliklerin belirtilen üyeye uygulanıp uygulanmadığını ve isteğe bağlı olarak, üstlerine uygulanıp uygulanmadığını gösterir.

GetTypeInfo(Type)

TypeInfo Belirtilen türün gösterimini döndürür.

GetMetadataToken(MemberInfo)

Varsa, verilen üye için bir meta veri belirteci alır.

HasMetadataToken(MemberInfo)

Belirtilen üye için bir meta veri belirtecinin kullanılabilir olup olmadığını gösteren bir değer döndürür.

GetRuntimeEvent(Type, String)

Belirtilen olayı temsil eden bir nesnesi alır.

GetRuntimeEvents(Type)

Belirtilen türde tanımlanan tüm olayları temsil eden bir koleksiyon alır.

GetRuntimeField(Type, String)

Belirtilen alanı temsil eden bir nesneyi alır.

GetRuntimeFields(Type)

Belirtilen türde tanımlanan tüm alanları temsil eden bir koleksiyonu alır.

GetRuntimeInterfaceMap(TypeInfo, Type)

Belirtilen tür ve belirtilen arabirim için bir arabirim eşlemesi döndürür.

GetRuntimeMethod(Type, String, Type[])

Belirtilen yöntemi temsil eden bir nesneyi alır.

GetRuntimeMethods(Type)

Belirtilen türde tanımlanan tüm yöntemleri temsil eden bir koleksiyon alır.

GetRuntimeProperties(Type)

Belirtilen türde tanımlanan tüm özellikleri temsil eden bir koleksiyon alır.

GetRuntimeProperty(Type, String)

Belirtilen özelliği temsil eden bir nesneyi alır.

GetConstructor(Type, Type[])

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

GetConstructors(Type)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

GetConstructors(Type, BindingFlags)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

GetFields(Type, BindingFlags)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

GetGenericArguments(Type)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

GetInterfaces(Type)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

GetMember(Type, String)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

GetMember(Type, String, BindingFlags)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

GetMembers(Type)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

GetMethods(Type)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

GetNestedType(Type, String, BindingFlags)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

GetProperties(Type)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

GetProperties(Type, BindingFlags)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

GetProperty(Type, String, BindingFlags)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

GetProperty(Type, String, Type)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

GetProperty(Type, String, Type, Type[])

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

IsAssignableFrom(Type, Type)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

IsInstanceOfType(Type, Object)

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

Şunlara uygulanır

Ayrıca bkz.