ConstructorBuilder Třída

Definice

Definuje a představuje konstruktor dynamické třídy.Defines and represents a constructor of a dynamic class.

public ref class ConstructorBuilder sealed : System::Reflection::ConstructorInfo, System::Runtime::InteropServices::_ConstructorBuilder
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class ConstructorBuilder : System.Reflection.ConstructorInfo, System.Runtime.InteropServices._ConstructorBuilder
type ConstructorBuilder = class
    inherit ConstructorInfo
    interface _ConstructorBuilder
Public NotInheritable Class ConstructorBuilder
Inherits ConstructorInfo
Implements _ConstructorBuilder
Dědičnost
Atributy
Implementuje

Příklady

Následující ukázka kódu ukazuje kontextové použití ConstructorBuilder.The following code sample illustrates the contextual usage of a ConstructorBuilder.

using namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
Type^ DynamicPointTypeGen()
{
   Type^ pointType = nullptr;
   array<Type^>^temp0 = {int::typeid,int::typeid,int::typeid};
   array<Type^>^ctorParams = temp0;
   AppDomain^ myDomain = Thread::GetDomain();
   AssemblyName^ myAsmName = gcnew AssemblyName;
   myAsmName->Name = "MyDynamicAssembly";
   AssemblyBuilder^ myAsmBuilder = myDomain->DefineDynamicAssembly( myAsmName, AssemblyBuilderAccess::RunAndSave );
   ModuleBuilder^ pointModule = myAsmBuilder->DefineDynamicModule( "PointModule", "Point.dll" );
   TypeBuilder^ pointTypeBld = pointModule->DefineType( "Point", TypeAttributes::Public );
   FieldBuilder^ xField = pointTypeBld->DefineField( "x", int::typeid, FieldAttributes::Public );
   FieldBuilder^ yField = pointTypeBld->DefineField( "y", int::typeid, FieldAttributes::Public );
   FieldBuilder^ zField = pointTypeBld->DefineField( "z", int::typeid, FieldAttributes::Public );
   Type^ objType = Type::GetType( "System.Object" );
   ConstructorInfo^ objCtor = objType->GetConstructor( gcnew array<Type^>(0) );
   ConstructorBuilder^ pointCtor = pointTypeBld->DefineConstructor( MethodAttributes::Public, CallingConventions::Standard, ctorParams );
   ILGenerator^ ctorIL = pointCtor->GetILGenerator();
   
   // NOTE: ldarg.0 holds the "this" reference - ldarg.1, ldarg.2, and ldarg.3
   // hold the actual passed parameters. ldarg.0 is used by instance methods
   // to hold a reference to the current calling bject instance. Static methods
   // do not use arg.0, since they are not instantiated and hence no reference
   // is needed to distinguish them.
   ctorIL->Emit( OpCodes::Ldarg_0 );
   
   // Here, we wish to create an instance of System::Object by invoking its
   // constructor, as specified above.
   ctorIL->Emit( OpCodes::Call, objCtor );
   
   // Now, we'll load the current instance in arg 0, along
   // with the value of parameter "x" stored in arg 1, into stfld.
   ctorIL->Emit( OpCodes::Ldarg_0 );
   ctorIL->Emit( OpCodes::Ldarg_1 );
   ctorIL->Emit( OpCodes::Stfld, xField );
   
   // Now, we store arg 2 "y" in the current instance with stfld.
   ctorIL->Emit( OpCodes::Ldarg_0 );
   ctorIL->Emit( OpCodes::Ldarg_2 );
   ctorIL->Emit( OpCodes::Stfld, yField );
   
   // Last of all, arg 3 "z" gets stored in the current instance.
   ctorIL->Emit( OpCodes::Ldarg_0 );
   ctorIL->Emit( OpCodes::Ldarg_3 );
   ctorIL->Emit( OpCodes::Stfld, zField );
   
   // Our work complete, we return.
   ctorIL->Emit( OpCodes::Ret );
   
   // Now, let's create three very simple methods so we can see our fields.
   array<String^>^temp1 = {"GetX","GetY","GetZ"};
   array<String^>^mthdNames = temp1;
   System::Collections::IEnumerator^ myEnum = mthdNames->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ mthdName = safe_cast<String^>(myEnum->Current);
      MethodBuilder^ getFieldMthd = pointTypeBld->DefineMethod( mthdName, MethodAttributes::Public, int::typeid, nullptr );
      ILGenerator^ mthdIL = getFieldMthd->GetILGenerator();
      mthdIL->Emit( OpCodes::Ldarg_0 );
      if ( mthdName->Equals( "GetX" ) )
            mthdIL->Emit( OpCodes::Ldfld, xField );
      else
      if ( mthdName->Equals( "GetY" ) )
            mthdIL->Emit( OpCodes::Ldfld, yField );
      else
      if ( mthdName->Equals( "GetZ" ) )
            mthdIL->Emit( OpCodes::Ldfld, zField );



      mthdIL->Emit( OpCodes::Ret );
   }

   pointType = pointTypeBld->CreateType();
   
   // Let's save it, just for posterity.
   myAsmBuilder->Save( "Point.dll" );
   return pointType;
}

int main()
{
   Type^ myDynamicType = nullptr;
   Object^ aPoint = nullptr;
   array<Type^>^temp2 = {int::typeid,int::typeid,int::typeid};
   array<Type^>^aPtypes = temp2;
   array<Object^>^temp3 = {4,5,6};
   array<Object^>^aPargs = temp3;
   
   // Call the  method to build our dynamic class.
   myDynamicType = DynamicPointTypeGen();
   Console::WriteLine( "Some information about my new Type '{0}':", myDynamicType->FullName );
   Console::WriteLine( "Assembly: '{0}'", myDynamicType->Assembly );
   Console::WriteLine( "Attributes: '{0}'", myDynamicType->Attributes );
   Console::WriteLine( "Module: '{0}'", myDynamicType->Module );
   Console::WriteLine( "Members: " );
   System::Collections::IEnumerator^ myEnum = myDynamicType->GetMembers()->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      MemberInfo^ member = safe_cast<MemberInfo^>(myEnum->Current);
      Console::WriteLine( "-- {0} {1};", member->MemberType, member->Name );
   }

   Console::WriteLine( "---" );
   
   // Let's take a look at the constructor we created.
   ConstructorInfo^ myDTctor = myDynamicType->GetConstructor( aPtypes );
   Console::WriteLine( "Constructor: {0};", myDTctor );
   Console::WriteLine( "---" );
   
   // Now, we get to use our dynamically-created class by invoking the constructor.
   aPoint = myDTctor->Invoke( aPargs );
   Console::WriteLine( "aPoint is type {0}.", aPoint->GetType() );
   
   // Finally, let's reflect on the instance of our new type - aPoint - and
   // make sure everything proceeded according to plan.
   Console::WriteLine( "aPoint.x = {0}", myDynamicType->InvokeMember( "GetX", BindingFlags::InvokeMethod, nullptr, aPoint, gcnew array<Object^>(0) ) );
   Console::WriteLine( "aPoint.y = {0}", myDynamicType->InvokeMember( "GetY", BindingFlags::InvokeMethod, nullptr, aPoint, gcnew array<Object^>(0) ) );
   Console::WriteLine( "aPoint.z = {0}", myDynamicType->InvokeMember( "GetZ", BindingFlags::InvokeMethod, nullptr, aPoint, gcnew array<Object^>(0) ) );
   
   // +++ OUTPUT +++
   // Some information about my new Type 'Point':
   // Assembly: 'MyDynamicAssembly, Version=0.0.0.0'
   // Attributes: 'AutoLayout, AnsiClass, NotPublic, Public'
   // Module: 'PointModule'
   // Members:
   // -- Field x;
   // -- Field y;
   // -- Field z;
   // -- Method GetHashCode;
   // -- Method Equals;
   // -- Method ToString;
   // -- Method GetType;
   // -- Constructor .ctor;
   // ---
   // Constructor: Void .ctor(Int32, Int32, Int32);
   // ---
   // aPoint is type Point.
   // aPoint.x = 4
   // aPoint.y = 5
   // aPoint.z = 6
}


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

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

       ModuleBuilder pointModule = myAsmBuilder.DefineDynamicModule("PointModule",
                                    "Point.dll");

       TypeBuilder pointTypeBld = pointModule.DefineType("Point",
                                      TypeAttributes.Public);

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

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

       ConstructorBuilder pointCtor = pointTypeBld.DefineConstructor(
                      MethodAttributes.Public,
                      CallingConventions.Standard,
                      ctorParams);
       ILGenerator ctorIL = pointCtor.GetILGenerator();

       // NOTE: ldarg.0 holds the "this" reference - ldarg.1, ldarg.2, and ldarg.3
       // hold the actual passed parameters. ldarg.0 is used by instance methods
       // to hold a reference to the current calling object instance. Static methods
       // do not use arg.0, since they are not instantiated and hence no reference
       // is needed to distinguish them. 

           ctorIL.Emit(OpCodes.Ldarg_0);

       // Here, we wish to create an instance of System.Object by invoking its
       // constructor, as specified above.

           ctorIL.Emit(OpCodes.Call, objCtor);

       // Now, we'll load the current instance ref in arg 0, along
       // with the value of parameter "x" stored in arg 1, into stfld.

           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Ldarg_1);
           ctorIL.Emit(OpCodes.Stfld, xField); 

       // Now, we store arg 2 "y" in the current instance with stfld.

           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Ldarg_2);
           ctorIL.Emit(OpCodes.Stfld, yField); 

       // Last of all, arg 3 "z" gets stored in the current instance.

           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Ldarg_3);
           ctorIL.Emit(OpCodes.Stfld, zField); 
           
           // Our work complete, we return.

       ctorIL.Emit(OpCodes.Ret); 

       // Now, let's create three very simple methods so we can see our fields.

       string[] mthdNames = new string[] {"GetX", "GetY", "GetZ"}; 

           foreach (string mthdName in mthdNames) {
              MethodBuilder getFieldMthd = pointTypeBld.DefineMethod(
                           mthdName, 
                           MethodAttributes.Public,
                                           typeof(int), 
                                           null);
          ILGenerator mthdIL = getFieldMthd.GetILGenerator();
       
          mthdIL.Emit(OpCodes.Ldarg_0);
          switch (mthdName) {
             case "GetX": mthdIL.Emit(OpCodes.Ldfld, xField);
                  break;
             case "GetY": mthdIL.Emit(OpCodes.Ldfld, yField);
                  break;
             case "GetZ": mthdIL.Emit(OpCodes.Ldfld, zField);
                  break;

          }
          mthdIL.Emit(OpCodes.Ret);

           }
       // Finally, we create the type.

       pointType = pointTypeBld.CreateType();

       // Let's save it, just for posterity.
       
       myAsmBuilder.Save("Point.dll");
    
       return pointType;

    }

    public static void Main() {
    
       Type myDynamicType = null;
           object aPoint = null;
       Type[] aPtypes = new Type[] {typeof(int), typeof(int), typeof(int)};
           object[] aPargs = new object[] {4, 5, 6};
    
       // Call the  method to build our dynamic class.

       myDynamicType = DynamicPointTypeGen();

       Console.WriteLine("Some information about my new Type '{0}':",
                  myDynamicType.FullName);
       Console.WriteLine("Assembly: '{0}'", myDynamicType.Assembly);
       Console.WriteLine("Attributes: '{0}'", myDynamicType.Attributes);
       Console.WriteLine("Module: '{0}'", myDynamicType.Module);
       Console.WriteLine("Members: "); 
       foreach (MemberInfo member in myDynamicType.GetMembers()) {
        Console.WriteLine("-- {0} {1};", member.MemberType, member.Name);
       }

           Console.WriteLine("---");

       // Let's take a look at the constructor we created.

       ConstructorInfo myDTctor = myDynamicType.GetConstructor(aPtypes);
           Console.WriteLine("Constructor: {0};", myDTctor.ToString());

           Console.WriteLine("---");
      
           // Now, we get to use our dynamically-created class by invoking the constructor. 

       aPoint = myDTctor.Invoke(aPargs);
           Console.WriteLine("aPoint is type {0}.", aPoint.GetType());

       // Finally, let's reflect on the instance of our new type - aPoint - and
       // make sure everything proceeded according to plan.

       Console.WriteLine("aPoint.x = {0}",
                 myDynamicType.InvokeMember("GetX",
                                BindingFlags.InvokeMethod,
                            null,
                            aPoint,
                            new object[0]));
       Console.WriteLine("aPoint.y = {0}",
                 myDynamicType.InvokeMember("GetY",
                                BindingFlags.InvokeMethod,
                            null,
                            aPoint,
                            new object[0]));
       Console.WriteLine("aPoint.z = {0}",
                 myDynamicType.InvokeMember("GetZ",
                                BindingFlags.InvokeMethod,
                            null,
                            aPoint,
                            new object[0]));

       // +++ OUTPUT +++
       // Some information about my new Type 'Point':
       // Assembly: 'MyDynamicAssembly, Version=0.0.0.0'
       // Attributes: 'AutoLayout, AnsiClass, NotPublic, Public'
       // Module: 'PointModule'
       // Members: 
       // -- Field x;
       // -- Field y;
       // -- Field z;
           // -- Method GetHashCode;
           // -- Method Equals;
           // -- Method ToString;
           // -- Method GetType;
           // -- Constructor .ctor;
       // ---
       // Constructor: Void .ctor(Int32, Int32, Int32);
       // ---
       // aPoint is type Point.
       // aPoint.x = 4
       // aPoint.y = 5
       // aPoint.z = 6
        
    }
    
}


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

 _

Class TestCtorBuilder
   
   
   Public Shared Function DynamicPointTypeGen() As Type
      
      Dim pointType 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 = "MyDynamicAssembly"
      
      Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.RunAndSave)
      
      Dim pointModule As ModuleBuilder = myAsmBuilder.DefineDynamicModule("PointModule", "Point.dll")
      
      Dim pointTypeBld As TypeBuilder = pointModule.DefineType("Point", TypeAttributes.Public)
      
      Dim xField As FieldBuilder = pointTypeBld.DefineField("x", GetType(Integer), FieldAttributes.Public)
      Dim yField As FieldBuilder = pointTypeBld.DefineField("y", GetType(Integer), FieldAttributes.Public)
      Dim zField As FieldBuilder = pointTypeBld.DefineField("z", GetType(Integer), FieldAttributes.Public)
      
      Dim objType As Type = Type.GetType("System.Object")
      Dim objCtor As ConstructorInfo = objType.GetConstructor(New Type() {})
      
      Dim pointCtor As ConstructorBuilder = pointTypeBld.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, ctorParams)
      Dim ctorIL As ILGenerator = pointCtor.GetILGenerator()
      
      ' NOTE: ldarg.0 holds the "this" reference - ldarg.1, ldarg.2, and ldarg.3
      ' hold the actual passed parameters. ldarg.0 is used by instance methods
      ' to hold a reference to the current calling object instance. Static methods
      ' do not use arg.0, since they are not instantiated and hence no reference
      ' is needed to distinguish them. 
      ctorIL.Emit(OpCodes.Ldarg_0)
      
      ' Here, we wish to create an instance of System.Object by invoking its
      ' constructor, as specified above.
      ctorIL.Emit(OpCodes.Call, objCtor)
      
      ' Now, we'll load the current instance ref in arg 0, along
      ' with the value of parameter "x" stored in arg 1, into stfld.
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_1)
      ctorIL.Emit(OpCodes.Stfld, xField)
      
      ' Now, we store arg 2 "y" in the current instance with stfld.
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_2)
      ctorIL.Emit(OpCodes.Stfld, yField)
      
      ' Last of all, arg 3 "z" gets stored in the current instance.
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_3)
      ctorIL.Emit(OpCodes.Stfld, zField)
      
      ' Our work complete, we return.
      ctorIL.Emit(OpCodes.Ret)
      
      ' Now, let's create three very simple methods so we can see our fields.
      Dim mthdNames() As String = {"GetX", "GetY", "GetZ"}
      
      Dim mthdName As String
      For Each mthdName In  mthdNames
         Dim getFieldMthd As MethodBuilder = pointTypeBld.DefineMethod(mthdName, MethodAttributes.Public, GetType(Integer), Nothing)
         Dim mthdIL As ILGenerator = getFieldMthd.GetILGenerator()
         
         mthdIL.Emit(OpCodes.Ldarg_0)
         Select Case mthdName
            Case "GetX"
               mthdIL.Emit(OpCodes.Ldfld, xField)
            Case "GetY"
               mthdIL.Emit(OpCodes.Ldfld, yField)
            Case "GetZ"
               mthdIL.Emit(OpCodes.Ldfld, zField)
         End Select
         
         mthdIL.Emit(OpCodes.Ret)
      Next mthdName 
      ' Finally, we create the type.
      pointType = pointTypeBld.CreateType()
      
      ' Let's save it, just for posterity.
      myAsmBuilder.Save("Point.dll")
      
      Return pointType
   End Function 'DynamicPointTypeGen
    
   
   Public Shared Sub Main()
      
      Dim myDynamicType As Type = Nothing
      Dim aPoint As Object = Nothing
      Dim aPtypes() As Type = {GetType(Integer), GetType(Integer), GetType(Integer)}
      Dim aPargs() As Object = {4, 5, 6}
      
      ' Call the  method to build our dynamic class.
      myDynamicType = DynamicPointTypeGen()
      
      Console.WriteLine("Some information about my new Type '{0}':", myDynamicType.FullName)
      Console.WriteLine("Assembly: '{0}'", myDynamicType.Assembly)
      Console.WriteLine("Attributes: '{0}'", myDynamicType.Attributes)
      Console.WriteLine("Module: '{0}'", myDynamicType.Module)
      Console.WriteLine("Members: ")
      Dim member As MemberInfo
      For Each member In  myDynamicType.GetMembers()
         Console.WriteLine("-- {0} {1};", member.MemberType, member.Name)
      Next member
      
      Console.WriteLine("---")
      
      ' Let's take a look at the constructor we created.
      Dim myDTctor As ConstructorInfo = myDynamicType.GetConstructor(aPtypes)
      Console.WriteLine("Constructor: {0};", myDTctor.ToString())
      
      Console.WriteLine("---")
      
      ' Now, we get to use our dynamically-created class by invoking the constructor. 
      aPoint = myDTctor.Invoke(aPargs)
      Console.WriteLine("aPoint is type {0}.", aPoint.GetType())
      
      
      ' Finally, let's reflect on the instance of our new type - aPoint - and
      ' make sure everything proceeded according to plan.
      Console.WriteLine("aPoint.x = {0}", myDynamicType.InvokeMember("GetX", BindingFlags.InvokeMethod, Nothing, aPoint, New Object() {}))
      Console.WriteLine("aPoint.y = {0}", myDynamicType.InvokeMember("GetY", BindingFlags.InvokeMethod, Nothing, aPoint, New Object() {}))
      Console.WriteLine("aPoint.z = {0}", myDynamicType.InvokeMember("GetZ", BindingFlags.InvokeMethod, Nothing, aPoint, New Object() {}))
   End Sub
End Class



' +++ OUTPUT +++
' Some information about my new Type 'Point':
' Assembly: 'MyDynamicAssembly, Version=0.0.0.0'
' Attributes: 'AutoLayout, AnsiClass, NotPublic, Public'
' Module: 'PointModule'
' Members: 
' -- Field x;
' -- Field y;
' -- Field z;
' -- Method GetHashCode;
' -- Method Equals;
' -- Method ToString;
' -- Method GetType;
' -- Constructor .ctor;
' ---
' Constructor: Void .ctor(Int32, Int32, Int32);
' ---
' aPoint is type Point.
' aPoint.x = 4
' aPoint.y = 5
' aPoint.z = 6

Poznámky

ConstructorBuilder slouží k úplnému popisu konstruktoru v jazyce MSIL (Microsoft Intermediate Language), včetně názvu, atributů, podpisu a těla konstruktoru.ConstructorBuilder is used to fully describe a constructor in Microsoft intermediate language (MSIL), including the name, attributes, signature, and constructor body. Používá se ve spojení s TypeBuilder třídou pro vytváření tříd v době běhu.It is used in conjunction with the TypeBuilder class to create classes at run time. Zavolejte DefineConstructor pro získání instance ConstructorBuilder.Call DefineConstructor to get an instance of ConstructorBuilder.

Pokud nedefinujete konstruktor pro svůj dynamický typ, konstruktor bez parametrů je k dispozici automaticky a volá konstruktor bez parametrů základní třídy.If you do not define a constructor for your dynamic type, a parameterless constructor is provided automatically, and it calls the parameterless constructor of the base class.

Použijete-li ConstructorBuilder k definování konstruktoru pro dynamický typ, není konstruktor bez parametrů k dispozici.If you use ConstructorBuilder to define a constructor for your dynamic type, a parameterless constructor is not provided. K dispozici jsou následující možnosti pro poskytnutí bezparametrového konstruktoru kromě konstruktoru, který jste definovali:You have the following options for providing a parameterless constructor in addition to the constructor you defined:

  • Pokud chcete konstruktor bez parametrů, který jednoduše volá konstruktor bez parametrů základní třídy, můžete použít metodu TypeBuilder.DefineDefaultConstructor k vytvoření jednoho (a volitelně omezit přístup k tomuto typu).If you want a parameterless constructor that simply calls the parameterless constructor of the base class, you can use the TypeBuilder.DefineDefaultConstructor method to create one (and optionally restrict access to it). Neposkytněte implementaci pro tento konstruktor bez parametrů.Do not provide an implementation for this parameterless constructor. Pokud tak učiníte, je vyvolána výjimka při pokusu o použití konstruktoru.If you do, an exception is thrown when you try to use the constructor. Pokud je volána metoda TypeBuilder.CreateType, není vyvolána žádná výjimka.No exception is thrown when the TypeBuilder.CreateType method is called.

  • Pokud chcete konstruktor bez parametrů, který je více než jednoduše volat konstruktor bez parametrů základní třídy, nebo který volá jiný konstruktor základní třídy, nebo něco jiného, je nutné použít metodu TypeBuilder.DefineConstructor k vytvoření ConstructorBuildera poskytnutí vlastní implementace.If you want a parameterless constructor that does something more than simply calling the parameterless constructor of the base class, or that calls another constructor of the base class, or that does something else entirely, you must use the TypeBuilder.DefineConstructor method to create a ConstructorBuilder, and provide your own implementation.

Vlastnosti

Attributes

Získá atributy pro tento konstruktor.Gets the attributes for this constructor.

CallingConvention

Získá CallingConventions hodnotu, která závisí na tom, zda je deklarující typ obecný.Gets a CallingConventions value that depends on whether the declaring type is generic.

ContainsGenericParameters

Načte hodnotu, která označuje, zda obecná metoda obsahuje nepřiřazené parametry obecného typu.Gets a value indicating whether the generic method contains unassigned generic type parameters.

(Zděděno od MethodBase)
CustomAttributes

Získá kolekci, která obsahuje vlastní atributy tohoto člena.Gets a collection that contains this member's custom attributes.

(Zděděno od MemberInfo)
DeclaringType

Získá odkaz na objekt Type pro typ, který deklaruje tohoto člena.Gets a reference to the Type object for the type that declares this member.

InitLocals

Získává nebo nastavuje, jestli se mají místní proměnné v tomto konstruktoru inicializovat nulou.Gets or sets whether the local variables in this constructor should be zero-initialized.

IsAbstract

Načte hodnotu, která označuje, jestli je metoda abstraktní.Gets a value indicating whether the method is abstract.

(Zděděno od MethodBase)
IsAssembly

Získá hodnotu, která označuje, zda je potenciální viditelnost této metody nebo konstruktoru popsána Assembly; To znamená, že metoda nebo konstruktor je vidět nejvíce k ostatním typům ve stejném sestavení a není viditelný pro odvozené typy mimo sestavení.Gets a value indicating whether the potential visibility of this method or constructor is described by Assembly; that is, the method or constructor is visible at most to other types in the same assembly, and is not visible to derived types outside the assembly.

(Zděděno od MethodBase)
IsCollectible

Získá hodnotu, která označuje, zda je tento objekt MemberInfo součástí sestavení uloženého v AssemblyLoadContextkolekční.Gets a value that indicates whether this MemberInfo object is part of an assembly held in a collectible AssemblyLoadContext.

(Zděděno od MemberInfo)
IsConstructedGenericMethod (Zděděno od MethodBase)
IsConstructor

Načte hodnotu, která označuje, jestli je metoda konstruktorem.Gets a value indicating whether the method is a constructor.

(Zděděno od MethodBase)
IsFamily

Načte hodnotu, která označuje, zda je tato metoda nebo konstruktor popsána pomocí Family; To znamená, že metoda nebo konstruktor je viditelná pouze v rámci své třídy a odvozených tříd.Gets a value indicating whether the visibility of this method or constructor is described by Family; that is, the method or constructor is visible only within its class and derived classes.

(Zděděno od MethodBase)
IsFamilyAndAssembly

Načte hodnotu, která označuje, zda je tato metoda nebo konstruktor popsána pomocí FamANDAssem; To znamená, že metoda nebo konstruktor mohou být volány odvozenými třídami, ale pouze v případě, že jsou ve stejném sestavení.Gets a value indicating whether the visibility of this method or constructor is described by FamANDAssem; that is, the method or constructor can be called by derived classes, but only if they are in the same assembly.

(Zděděno od MethodBase)
IsFamilyOrAssembly

Získá hodnotu, která označuje, zda je potenciální viditelnost této metody nebo konstruktoru popsána FamORAssem; To znamená, že metoda nebo konstruktor mohou být volány odvozenými třídami bez ohledu na ně a třídy ve stejném sestavení.Gets a value indicating whether the potential visibility of this method or constructor is described by FamORAssem; that is, the method or constructor can be called by derived classes wherever they are, and by classes in the same assembly.

(Zděděno od MethodBase)
IsFinal

Získá hodnotu, která označuje, zda je tato metoda final.Gets a value indicating whether this method is final.

(Zděděno od MethodBase)
IsGenericMethod

Získá hodnotu, která označuje, zda je metoda obecná.Gets a value indicating whether the method is generic.

(Zděděno od MethodBase)
IsGenericMethodDefinition

Získá hodnotu, která označuje, zda je metoda definicí obecné metody.Gets a value indicating whether the method is a generic method definition.

(Zděděno od MethodBase)
IsHideBySig

Získá hodnotu, která označuje, zda je v odvozené třídě skrytý pouze člen stejného typu, který má přesně stejný podpis.Gets a value indicating whether only a member of the same kind with exactly the same signature is hidden in the derived class.

(Zděděno od MethodBase)
IsPrivate

Načte hodnotu, která označuje, jestli je tento člen soukromý.Gets a value indicating whether this member is private.

(Zděděno od MethodBase)
IsPublic

Načte hodnotu, která označuje, zda se jedná o veřejnou metodu.Gets a value indicating whether this is a public method.

(Zděděno od MethodBase)
IsSecurityCritical

Získá hodnotu, která označuje, zda je aktuální metoda nebo konstruktor v aktuální úrovni vztahu důvěryhodnosti kritický pro zabezpečení nebo bezpečný a proto může provádět kritické operace.Gets a value that indicates whether the current method or constructor is security-critical or security-safe-critical at the current trust level, and therefore can perform critical operations.

(Zděděno od MethodBase)
IsSecuritySafeCritical

Získá hodnotu, která označuje, zda je aktuální metoda nebo konstruktor v aktuální úrovni vztahu důvěryhodnosti zabezpečený. To znamená, zda může provádět kritické operace a lze k němu přistupovat transparentním kódem.Gets a value that indicates whether the current method or constructor is security-safe-critical at the current trust level; that is, whether it can perform critical operations and can be accessed by transparent code.

(Zděděno od MethodBase)
IsSecurityTransparent

Získá hodnotu, která označuje, zda je aktuální metoda nebo konstruktor transparentní na aktuální úrovni vztahu důvěryhodnosti, a proto nemůže provádět kritické operace.Gets a value that indicates whether the current method or constructor is transparent at the current trust level, and therefore cannot perform critical operations.

(Zděděno od MethodBase)
IsSpecialName

Načte hodnotu, která označuje, jestli má tato metoda speciální název.Gets a value indicating whether this method has a special name.

(Zděděno od MethodBase)
IsStatic

Načte hodnotu, která označuje, jestli je metoda static.Gets a value indicating whether the method is static.

(Zděděno od MethodBase)
IsVirtual

Načte hodnotu, která označuje, jestli je metoda virtual.Gets a value indicating whether the method is virtual.

(Zděděno od MethodBase)
MemberType

Získá MemberTypes hodnotu označující, že tento člen je konstruktor.Gets a MemberTypes value indicating that this member is a constructor.

(Zděděno od ConstructorInfo)
MetadataToken

Získá hodnotu, která identifikuje element metadat.Gets a value that identifies a metadata element.

(Zděděno od MemberInfo)
MethodHandle

Získá vnitřní popisovač pro metodu.Gets the internal handle for the method. Tento popisovač použijte pro přístup k základnímu popisovači metadat.Use this handle to access the underlying metadata handle.

MethodImplementationFlags

Získá příznaky MethodImplAttributes, které určují atributy implementace metody.Gets the MethodImplAttributes flags that specify the attributes of a method implementation.

Module

Získá dynamický modul, ve kterém je definován tento konstruktor.Gets the dynamic module in which this constructor is defined.

Name

Načte název tohoto konstruktoru.Retrieves the name of this constructor.

ReflectedType

Obsahuje odkaz na objekt Type, ze kterého byl tento objekt získán.Holds a reference to the Type object from which this object was obtained.

ReturnType

Získá null.Gets null.

Signature

Načte podpis pole ve formě řetězce.Retrieves the signature of the field in the form of a string.

Metody

AddDeclarativeSecurity(SecurityAction, PermissionSet)

Přidá k tomuto konstruktoru deklarativní zabezpečení.Adds declarative security to this constructor.

DefineParameter(Int32, ParameterAttributes, String)

Definuje parametr tohoto konstruktoru.Defines a parameter of this constructor.

Equals(Object)

Vrací hodnotu, která určuje, zda je tato instance rovna zadanému objektu.Returns a value that indicates whether this instance is equal to a specified object.

(Zděděno od ConstructorInfo)
GetCustomAttributes(Boolean)

Vrátí všechny vlastní atributy definované pro tento konstruktor.Returns all the custom attributes defined for this constructor.

GetCustomAttributes(Type, Boolean)

Vrátí vlastní atributy identifikované daným typem.Returns the custom attributes identified by the given type.

GetCustomAttributesData()

Vrátí seznam objektů CustomAttributeData reprezentujících data o atributech, které byly aplikovány na cílového člena.Returns a list of CustomAttributeData objects representing data about the attributes that have been applied to the target member.

(Zděděno od MemberInfo)
GetGenericArguments()

Vrátí pole objektů Type, které reprezentují argumenty typu Obecné metody nebo parametry typu definice obecné metody.Returns an array of Type objects that represent the type arguments of a generic method or the type parameters of a generic method definition.

(Zděděno od MethodBase)
GetHashCode()

Vrátí kód hash této instance.Returns the hash code for this instance.

(Zděděno od ConstructorInfo)
GetILGenerator()

Získá ILGenerator pro tento konstruktor.Gets an ILGenerator for this constructor.

GetILGenerator(Int32)

Získá objekt ILGenerator se zadanou velikostí datového proudu jazyka MSIL, který lze použít k vytvoření těla metody pro tento konstruktor.Gets an ILGenerator object, with the specified MSIL stream size, that can be used to build a method body for this constructor.

GetMethodBody()

Při přepsání v odvozené třídě získá objekt MethodBody, který poskytuje přístup k datovému proudu MSIL, místním proměnným a výjimkám pro aktuální metodu.When overridden in a derived class, gets a MethodBody object that provides access to the MSIL stream, local variables, and exceptions for the current method.

(Zděděno od MethodBase)
GetMethodImplementationFlags()

Vrátí příznaky implementace metody pro tento konstruktor.Returns the method implementation flags for this constructor.

GetModule()

Vrátí odkaz na modul, který obsahuje tento konstruktor.Returns a reference to the module that contains this constructor.

GetParameters()

Vrátí parametry tohoto konstruktoru.Returns the parameters of this constructor.

GetToken()

Vrátí MethodToken, který představuje token pro tento konstruktor.Returns the MethodToken that represents the token for this constructor.

GetType() (Zděděno od ConstructorInfo)
HasSameMetadataDefinitionAs(MemberInfo) (Zděděno od MemberInfo)
Invoke(BindingFlags, Binder, Object[], CultureInfo)

Dynamicky vyvolá konstruktor reprezentovaný touto instancí na daném objektu, projde zadanými parametry a v omezeních daného pořadače.Dynamically invokes the constructor represented by this instance on the given object, passing along the specified parameters, and under the constraints of the given binder.

Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)

Dynamicky vyvolá konstruktor odrážející tuto instanci se zadanými argumenty v rámci omezení zadaného Binder.Dynamically invokes the constructor reflected by this instance with the specified arguments, under the constraints of the specified Binder.

Invoke(Object, Object[])

Vyvolá metodu nebo konstruktor reprezentovaný aktuální instancí pomocí zadaných parametrů.Invokes the method or constructor represented by the current instance, using the specified parameters.

(Zděděno od MethodBase)
Invoke(Object[])

Vyvolá konstruktor odrážející instanci, která má zadané parametry, a poskytuje výchozí hodnoty pro parametry, které nejsou běžně používány.Invokes the constructor reflected by the instance that has the specified parameters, providing default values for the parameters not commonly used.

(Zděděno od ConstructorInfo)
IsDefined(Type, Boolean)

Kontroluje, zda je definován zadaný typ vlastního atributu.Checks if the specified custom attribute type is defined.

MemberwiseClone()

Vytvoří kopii aktuálního Objectbez podstruktury.Creates a shallow copy of the current Object.

(Zděděno od Object)
SetCustomAttribute(ConstructorInfo, Byte[])

Nastavte vlastní atribut pomocí zadaného objektu BLOB vlastního atributu.Set a custom attribute using a specified custom attribute blob.

SetCustomAttribute(CustomAttributeBuilder)

Nastavte vlastní atribut pomocí vlastního tvůrce atributů.Set a custom attribute using a custom attribute builder.

SetImplementationFlags(MethodImplAttributes)

Nastaví pro tento konstruktor příznaky implementace metody.Sets the method implementation flags for this constructor.

SetMethodBody(Byte[], Int32, Byte[], IEnumerable<ExceptionHandler>, IEnumerable<Int32>)

Vytvoří tělo konstruktoru pomocí zadaného bajtového pole instrukcí jazyka MSIL (Microsoft Intermediate Language).Creates the body of the constructor by using a specified byte array of Microsoft intermediate language (MSIL) instructions.

SetSymCustomAttribute(String, Byte[])

Nastaví vlastní atribut tohoto konstruktoru, který je přidružený k symbolickým informacím.Sets this constructor's custom attribute associated with symbolic information.

ToString()

Vrátí tuto instanci ConstructorBuilder jako String.Returns this ConstructorBuilder instance as a String.

Explicitní implementace rozhraní

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

Mapuje sadu názvů na odpovídající sadu identifikátorů pro rozesílání.Maps a set of names to a corresponding set of dispatch identifiers.

_ConstructorBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)

Načte informace o typu objektu, který lze použít k získání informací o typu pro rozhraní.Retrieves the type information for an object, which can then be used to get the type information for an interface.

_ConstructorBuilder.GetTypeInfoCount(UInt32)

Získá počet rozhraní typu informací, které objekt poskytuje (0 nebo 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

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

Poskytuje přístup k vlastnostem a metodám vystaveným objektem.Provides access to properties and methods exposed by an object.

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

Mapuje sadu názvů na odpovídající sadu identifikátorů pro rozesílání.Maps a set of names to a corresponding set of dispatch identifiers.

(Zděděno od ConstructorInfo)
_ConstructorInfo.GetType()

Získá objekt Type reprezentující typ ConstructorInfo.Gets a Type object representing the ConstructorInfo type.

(Zděděno od ConstructorInfo)
_ConstructorInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Načte informace o typu objektu, který lze použít k získání informací o typu pro rozhraní.Retrieves the type information for an object, which can then be used to get the type information for an interface.

(Zděděno od ConstructorInfo)
_ConstructorInfo.GetTypeInfoCount(UInt32)

Získá počet rozhraní typu informací, které objekt poskytuje (0 nebo 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Zděděno od ConstructorInfo)
_ConstructorInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Poskytuje přístup k vlastnostem a metodám vystaveným objektem.Provides access to properties and methods exposed by an object.

(Zděděno od ConstructorInfo)
_ConstructorInfo.Invoke_2(Object, BindingFlags, Binder, Object[], CultureInfo)

Poskytuje objekty modelu COM, které mají přístup k metodě Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) nezávislé na verzi.Provides COM objects with version-independent access to the Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) method.

(Zděděno od ConstructorInfo)
_ConstructorInfo.Invoke_3(Object, Object[])

Poskytuje objekty modelu COM, které mají přístup k metodě Invoke(Object, Object[]) nezávislé na verzi.Provides COM objects with version-independent access to the Invoke(Object, Object[]) method.

(Zděděno od ConstructorInfo)
_ConstructorInfo.Invoke_4(BindingFlags, Binder, Object[], CultureInfo)

Poskytuje objekty modelu COM, které mají přístup k metodě Invoke(BindingFlags, Binder, Object[], CultureInfo) nezávislé na verzi.Provides COM objects with version-independent access to the Invoke(BindingFlags, Binder, Object[], CultureInfo) method.

(Zděděno od ConstructorInfo)
_ConstructorInfo.Invoke_5(Object[])

Poskytuje objekty modelu COM, které mají přístup k metodě Invoke(Object[]) nezávislé na verzi.Provides COM objects with version-independent access to the Invoke(Object[]) method.

(Zděděno od ConstructorInfo)
_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mapuje sadu názvů na odpovídající sadu identifikátorů pro rozesílání.Maps a set of names to a corresponding set of dispatch identifiers.

(Zděděno od MemberInfo)
_MemberInfo.GetType()

Získá objekt Type reprezentující MemberInfo třídu.Gets a Type object representing the MemberInfo class.

(Zděděno od MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Načte informace o typu objektu, který lze použít k získání informací o typu pro rozhraní.Retrieves the type information for an object, which can then be used to get the type information for an interface.

(Zděděno od MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

Získá počet rozhraní typu informací, které objekt poskytuje (0 nebo 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Zděděno od MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Poskytuje přístup k vlastnostem a metodám vystaveným objektem.Provides access to properties and methods exposed by an object.

(Zděděno od MemberInfo)
_MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mapuje sadu názvů na odpovídající sadu identifikátorů pro rozesílání.Maps a set of names to a corresponding set of dispatch identifiers.

(Zděděno od MethodBase)
_MethodBase.GetType()

Popis tohoto člena naleznete v tématu GetType().For a description of this member, see GetType().

(Zděděno od MethodBase)
_MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr)

Načte informace o typu objektu, který lze použít k získání informací o typu pro rozhraní.Retrieves the type information for an object, which can then be used to get the type information for an interface.

(Zděděno od MethodBase)
_MethodBase.GetTypeInfoCount(UInt32)

Získá počet rozhraní typu informací, které objekt poskytuje (0 nebo 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Zděděno od MethodBase)
_MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Poskytuje přístup k vlastnostem a metodám vystaveným objektem.Provides access to properties and methods exposed by an object.

(Zděděno od MethodBase)
_MethodBase.IsAbstract

Popis tohoto člena naleznete v tématu IsAbstract.For a description of this member, see IsAbstract.

(Zděděno od MethodBase)
_MethodBase.IsAssembly

Popis tohoto člena naleznete v tématu IsAssembly.For a description of this member, see IsAssembly.

(Zděděno od MethodBase)
_MethodBase.IsConstructor

Popis tohoto člena naleznete v tématu IsConstructor.For a description of this member, see IsConstructor.

(Zděděno od MethodBase)
_MethodBase.IsFamily

Popis tohoto člena naleznete v tématu IsFamily.For a description of this member, see IsFamily.

(Zděděno od MethodBase)
_MethodBase.IsFamilyAndAssembly

Popis tohoto člena naleznete v tématu IsFamilyAndAssembly.For a description of this member, see IsFamilyAndAssembly.

(Zděděno od MethodBase)
_MethodBase.IsFamilyOrAssembly

Popis tohoto člena naleznete v tématu IsFamilyOrAssembly.For a description of this member, see IsFamilyOrAssembly.

(Zděděno od MethodBase)
_MethodBase.IsFinal

Popis tohoto člena naleznete v tématu IsFinal.For a description of this member, see IsFinal.

(Zděděno od MethodBase)
_MethodBase.IsHideBySig

Popis tohoto člena naleznete v tématu IsHideBySig.For a description of this member, see IsHideBySig.

(Zděděno od MethodBase)
_MethodBase.IsPrivate

Popis tohoto člena naleznete v tématu IsPrivate.For a description of this member, see IsPrivate.

(Zděděno od MethodBase)
_MethodBase.IsPublic

Popis tohoto člena naleznete v tématu IsPublic.For a description of this member, see IsPublic.

(Zděděno od MethodBase)
_MethodBase.IsSpecialName

Popis tohoto člena naleznete v tématu IsSpecialName.For a description of this member, see IsSpecialName.

(Zděděno od MethodBase)
_MethodBase.IsStatic

Popis tohoto člena naleznete v tématu IsStatic.For a description of this member, see IsStatic.

(Zděděno od MethodBase)
_MethodBase.IsVirtual

Popis tohoto člena naleznete v tématu IsVirtual.For a description of this member, see IsVirtual.

(Zděděno od MethodBase)
ICustomAttributeProvider.GetCustomAttributes(Boolean) (Zděděno od MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean) (Zděděno od MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean) (Zděděno od MemberInfo)

Metody rozšíření

GetCustomAttribute(MemberInfo, Type)

Načte vlastní atribut zadaného typu, který se použije pro zadaného člena.Retrieves a custom attribute of a specified type that is applied to a specified member.

GetCustomAttribute(MemberInfo, Type, Boolean)

Načte vlastní atribut zadaného typu, který se použije na zadaného člena, a volitelně zkontroluje nadřazené členy daného člena.Retrieves a custom attribute of a specified type that is applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttribute<T>(MemberInfo)

Načte vlastní atribut zadaného typu, který se použije pro zadaného člena.Retrieves a custom attribute of a specified type that is applied to a specified member.

GetCustomAttribute<T>(MemberInfo, Boolean)

Načte vlastní atribut zadaného typu, který se použije na zadaného člena, a volitelně zkontroluje nadřazené členy daného člena.Retrieves a custom attribute of a specified type that is applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes(MemberInfo)

Načte kolekci vlastních atributů, které se aplikují na zadaného člena.Retrieves a collection of custom attributes that are applied to a specified member.

GetCustomAttributes(MemberInfo, Boolean)

Načte kolekci vlastních atributů, které se aplikují na zadaného člena, a volitelně zkontroluje nadřazené členy daného člena.Retrieves a collection of custom attributes that are applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes(MemberInfo, Type)

Načte kolekci vlastních atributů zadaného typu, které jsou aplikovány na zadaného člena.Retrieves a collection of custom attributes of a specified type that are applied to a specified member.

GetCustomAttributes(MemberInfo, Type, Boolean)

Načte kolekci vlastních atributů zadaného typu, které jsou aplikovány na zadaného člena, a volitelně zkontroluje nadřazené členy daného člena.Retrieves a collection of custom attributes of a specified type that are applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes<T>(MemberInfo)

Načte kolekci vlastních atributů zadaného typu, které jsou aplikovány na zadaného člena.Retrieves a collection of custom attributes of a specified type that are applied to a specified member.

GetCustomAttributes<T>(MemberInfo, Boolean)

Načte kolekci vlastních atributů zadaného typu, které jsou aplikovány na zadaného člena, a volitelně zkontroluje nadřazené členy daného člena.Retrieves a collection of custom attributes of a specified type that are applied to a specified member, and optionally inspects the ancestors of that member.

IsDefined(MemberInfo, Type)

Určuje, zda jsou pro zadaného člena aplikovány vlastní atributy zadaného typu.Indicates whether custom attributes of a specified type are applied to a specified member.

IsDefined(MemberInfo, Type, Boolean)

Označuje, zda jsou vlastní atributy zadaného typu aplikovány na zadaného člena a volitelně také aplikován na jeho nadřazené prvky.Indicates whether custom attributes of a specified type are applied to a specified member, and, optionally, applied to its ancestors.

GetMetadataToken(MemberInfo)

Získá token metadat pro daného člena, je-li k dispozici.Gets a metadata token for the given member, if available.

HasMetadataToken(MemberInfo)

Vrátí hodnotu, která označuje, zda je pro zadaného člena k dispozici token metadat.Returns a value that indicates whether a metadata token is available for the specified member.

Platí pro