ConstructorBuilder Klasse

Definition

Definiert einen Konstruktor einer dynamischen Klasse und stellt diesen dar.

public ref class ConstructorBuilder sealed : System::Reflection::ConstructorInfo
public ref class ConstructorBuilder sealed : System::Reflection::ConstructorInfo, System::Runtime::InteropServices::_ConstructorBuilder
public ref class ConstructorBuilder abstract : System::Reflection::ConstructorInfo
public sealed class ConstructorBuilder : System.Reflection.ConstructorInfo
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
public sealed class ConstructorBuilder : 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
public abstract class ConstructorBuilder : System.Reflection.ConstructorInfo
type ConstructorBuilder = class
    inherit ConstructorInfo
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
type ConstructorBuilder = class
    inherit ConstructorInfo
    interface _ConstructorBuilder
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ConstructorBuilder = class
    inherit ConstructorInfo
    interface _ConstructorBuilder
Public NotInheritable Class ConstructorBuilder
Inherits ConstructorInfo
Public NotInheritable Class ConstructorBuilder
Inherits ConstructorInfo
Implements _ConstructorBuilder
Public MustInherit Class ConstructorBuilder
Inherits ConstructorInfo
Vererbung
Attribute
Implementiert

Beispiele

Im folgenden Codebeispiel wird die kontextbezogene Verwendung einer 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

Hinweise

ConstructorBuilder wird verwendet, um einen Konstruktor in Microsoft-Zwischensprache (MSIL) vollständig zu beschreiben, einschließlich des Namens, der Attribute, der Signatur und des Konstruktortexts. Es wird in Verbindung mit der TypeBuilder Klasse verwendet, um Klassen zur Laufzeit zu erstellen. Rufen Sie DefineConstructor auf, um eine Instanz von ConstructorBuilder.

Wenn Sie keinen Konstruktor für ihren dynamischen Typ definieren, wird automatisch ein parameterloser Konstruktor bereitgestellt, und er ruft den Parameterlosen Konstruktor der Basisklasse auf.

Wenn Sie ConstructorBuilder einen Konstruktor für ihren dynamischen Typ definieren, wird kein Parameterloser Konstruktor bereitgestellt. Sie verfügen über die folgenden Optionen zum Bereitstellen eines parameterlosen Konstruktors zusätzlich zum von Ihnen definierten Konstruktor:

  • Wenn Sie einen parameterlosen Konstruktor benötigen, der einfach den Parameterlosen Konstruktor der Basisklasse aufruft, können Sie die TypeBuilder.DefineDefaultConstructor Methode verwenden, um eine zu erstellen (und optional den Zugriff darauf einzuschränken). Stellen Sie keine Implementierung für diesen parameterlosen Konstruktor bereit. Wenn Sie tun, wird eine Ausnahme ausgelöst, wenn Sie versuchen, den Konstruktor zu verwenden. Es wird keine Ausnahme ausgelöst, wenn die TypeBuilder.CreateType Methode aufgerufen wird.

  • Wenn Sie einen parameterlosen Konstruktor benötigen, der etwas mehr als einfach den Parameterlosen Konstruktor der Basisklasse aufruft oder einen anderen Konstruktor der Basisklasse aufruft oder etwas anderes erledigt, müssen Sie die TypeBuilder.DefineConstructor Methode verwenden, um eine ConstructorBuilder, und ihre eigene Implementierung bereitzustellen.

Konstruktoren

ConstructorBuilder()

Initialisiert eine neue Instanz der ConstructorBuilder-Klasse.

Eigenschaften

Attributes

Ruft die Attribute für diesen Konstruktor ab.

CallingConvention

Ruft einen CallingConventions-Wert ab, der davon abhängt, ob der deklarierende Typ generisch ist.

CallingConvention

Ruft einen Wert ab, der die Aufrufkonventionen für diese Methode angibt.

(Geerbt von MethodBase)
ContainsGenericParameters

Ruft einen Wert ab, der angibt, ob die generische Methode nicht zugewiesene generische Typparameter enthält.

(Geerbt von MethodBase)
CustomAttributes

Ruft eine Sammlung ab, die die benutzerdefinierten Attribute dieses Members enthält.

(Geerbt von MemberInfo)
DeclaringType

Ruft einen Verweis auf das Type-Objekt für den Typ ab, der diesen Member deklariert.

InitLocals

Ruft die Information ab, ob die lokalen Variablen in diesem Konstruktor mit 0 (null) initialisiert werden sollen, oder legt diese Information fest.

IsAbstract

Ruft einen Wert ab, der angibt, ob es sich um eine abstrakte Methode handelt.

(Geerbt von MethodBase)
IsAssembly

Ruft einen Wert ab, der angibt, ob die potenzielle Sichtbarkeit dieser Methode bzw. dieses Konstruktors von Assembly beschrieben wird, d. h., die Methode oder der Konstruktor ist höchstens für andere Typen in derselben Assembly sichtbar, nicht jedoch für abgeleitete Typen außerhalb der Assembly.

(Geerbt von MethodBase)
IsCollectible

Ruft einen Wert ab, der angibt, ob dieses AssemblyLoadContext-Objekt Teil einer Assembly ist, die sich in einem entladbaren MemberInfo befindet.

(Geerbt von MemberInfo)
IsConstructedGenericMethod (Geerbt von MethodBase)
IsConstructor

Ruft einen Wert ab, der angibt, ob die Methode ein Konstruktor ist.

(Geerbt von MethodBase)
IsFamily

Ruft einen Wert ab, der angibt, ob die Sichtbarkeit dieser Methode bzw. dieses Konstruktors durch Family beschrieben wird, d. h., die Methode oder der Konstruktor ist nur sichtbar innerhalb ihrer bzw. seiner Klassen und in den abgeleiteten Klassen.

(Geerbt von MethodBase)
IsFamilyAndAssembly

Ruft einen Wert ab, der angibt, ob die Sichtbarkeit dieser Methode oder dieses Konstruktors durch FamANDAssem beschrieben wird, d. h., die Methode oder der Konstruktor kann von abgeleiteten Klassen aufgerufen werden, jedoch nur, wenn sie bzw. er sich in derselben Assembly befindet.

(Geerbt von MethodBase)
IsFamilyOrAssembly

Ruft einen Wert ab, der angibt, ob die potenzielle Sichtbarkeit dieser Methode oder dieses Konstruktors durch FamORAssem beschrieben wird, d. h., die Methode bzw. der Konstruktor kann von Klassen in derselben Assembly und von abgeleiteten Klassen abgerufen werden, wobei es keine Rolle spielt, an welcher Position sich diese befinden.

(Geerbt von MethodBase)
IsFinal

Ruft einen Wert ab, der angibt, ob diese Methode final ist.

(Geerbt von MethodBase)
IsGenericMethod

Ruft einen Wert ab, der angibt, ob es sich um eine generische Methode handelt.

(Geerbt von MethodBase)
IsGenericMethodDefinition

Ruft einen Wert ab, der angibt, ob die Methode eine generische Methodendefinition ist.

(Geerbt von MethodBase)
IsHideBySig

Ruft einen Wert ab, der angibt, ob nur ein Member derselben Art mit einer identischen Signatur in der abgeleiteten Klasse verborgen ist.

(Geerbt von MethodBase)
IsPrivate

Ruft einen Wert ab, der angibt, ob es sich um einen privaten Member handelt.

(Geerbt von MethodBase)
IsPublic

Ruft einen Wert ab, der angibt, ob dies eine öffentliche Methode ist.

(Geerbt von MethodBase)
IsSecurityCritical

Ruft einen Wert ab, der angibt, ob die aktuelle Methode oder der aktuelle Konstruktor auf der aktuellen Vertrauensebene sicherheitsrelevant oder sicherheitsrelevant und sicher zugänglich ist und daher wichtige Vorgänge ausführen darf.

(Geerbt von MethodBase)
IsSecuritySafeCritical

Ruft einen Wert ab, der angibt, ob die aktuelle Methode oder der aktuelle Konstruktor auf der aktuellen Vertrauensebene sicherheitsrelevant ist, d. h., ob sie bzw. er wichtige Vorgänge ausführen darf und ob von transparentem Code darauf zugegriffen werden kann.

(Geerbt von MethodBase)
IsSecurityTransparent

Ruft einen Wert ab, der angibt, ob die aktuelle Methode oder der aktuelle Konstruktor auf der aktuellen Vertrauensebene sicherheitstransparent ist und daher keine wichtigen Vorgänge ausführen kann.

(Geerbt von MethodBase)
IsSpecialName

Ruft einen Wert ab, der angibt, ob diese Methode einen besonderen Namen hat.

(Geerbt von MethodBase)
IsStatic

Ruft einen Wert ab, der angibt, ob die Methode static ist.

(Geerbt von MethodBase)
IsVirtual

Ruft einen Wert ab, der angibt, ob die Methode virtual ist.

(Geerbt von MethodBase)
MemberType

Ruft einen MemberTypes-Wert ab, der angibt, dass dieser Member ein Konstruktor ist.

(Geerbt von ConstructorInfo)
MetadataToken

Ruft ein Token ab, das das aktuelle dynamische Modul in den Metadaten angibt.

MetadataToken

Ruft einen Wert ab, der ein Metadatenelement identifiziert.

(Geerbt von MemberInfo)
MethodHandle

Ruft das interne Handle für die Methode ab. Verwenden Sie dieses Handle, um auf das zugrunde liegende Metadatenhandle zuzugreifen.

MethodHandle

Ruft ein Handle für die interne Metadatendarstellung einer Methode ab.

(Geerbt von MethodBase)
MethodImplementationFlags

Ruft die MethodImplAttributes-Flags ab, die die Attribute einer Methodenimplementierung angeben.

MethodImplementationFlags

Ruft die MethodImplAttributes-Flags ab, die die Attribute einer Methodenimplementierung angeben.

(Geerbt von MethodBase)
Module

Ruft das dynamische Modul ab, in dem dieser Konstruktor definiert ist.

Module

Ruft das Modul ab, in dem der Typ definiert ist, der den von der aktuellen MemberInfo-Klasse dargestellten Member deklariert.

(Geerbt von MemberInfo)
Name

Ruft den Namen des Konstruktors ab.

ReflectedType

Enthält einen Verweis auf das Type-Objekt, aus dem dieses Objekt abgerufen wurde.

ReflectedType

Ruft das Klassenobjekt ab, mit dem diese Instanz von MemberInfo abgerufen wurde.

(Geerbt von MemberInfo)
ReturnType
Veraltet.
Veraltet.

Ruft null ab.

Signature

Ruft die Signatur des Felds in Form einer Zeichenfolge ab.

Methoden

AddDeclarativeSecurity(SecurityAction, PermissionSet)

Fügt diesem Konstruktor deklarative Sicherheit hinzu.

DefineParameter(Int32, ParameterAttributes, String)

Definiert einen Parameter dieses Konstruktors.

Equals(Object)

Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.

(Geerbt von ConstructorInfo)
GetCustomAttributes(Boolean)

Gibt alle benutzerdefinierten Attribute zurück, die für diesen Konstruktor definiert sind.

GetCustomAttributes(Boolean)

Gibt beim Überschreiben in einer abgeleiteten Klasse ein Array mit allen benutzerdefinierten Attributen zurück, die auf diesen Member angewendet wurden.

(Geerbt von MemberInfo)
GetCustomAttributes(Type, Boolean)

Gibt die benutzerdefinierten Attribute zurück, die durch den angegebenen Typ identifiziert werden.

GetCustomAttributes(Type, Boolean)

Gibt beim Überschreiben in einer abgeleiteten Klasse ein Array aus benutzerdefinierten Attributen zurück, die auf diesen Member angewendet und von Type identifiziert wurden.

(Geerbt von MemberInfo)
GetCustomAttributesData()

Gibt eine Liste von CustomAttributeData-Objekten zurück, die Daten zu den Attributen darstellen, die auf den Zielmember angewendet wurden.

(Geerbt von MemberInfo)
GetGenericArguments()

Gibt ein Array von Type-Objekten zurück, die die Typargumente einer generischen Methode oder die Typparameter einer generischen Methodendefinition darstellen.

(Geerbt von MethodBase)
GetHashCode()

Gibt den Hashcode für diese Instanz zurück.

(Geerbt von ConstructorInfo)
GetILGenerator()

Ruft einen ILGenerator für diesen Konstruktor ab.

GetILGenerator(Int32)

Ruft ein ILGenerator-Objekt mit der angegebenen MSIL-Streamgröße ab, mit dem ein Methodentext für diesen Konstruktor erstellt werden kann.

GetMethodBody()

Ruft beim Überschreiben in einer abgeleiteten Klasse ein MethodBody-Objekt ab, das den Zugriff auf den MSIL-Stream, auf lokale Variablen und auf Ausnahmen für die aktuelle Methode ermöglicht.

(Geerbt von MethodBase)
GetMethodImplementationFlags()

Gibt die Methodenimplementierungsflags für diesen Konstruktor zurück.

GetMethodImplementationFlags()

Erstellt beim Überschreiben in einer abgeleiteten Klasse die MethodImplAttributes-Flags.

(Geerbt von MethodBase)
GetModule()

Gibt einen Verweis auf das Modul zurück, das diesen Konstruktor enthält.

GetParameters()

Gibt den Parameter dieses Konstruktors zurück.

GetToken()

Gibt das MethodToken zurück, das das Token für diesen Konstruktor darstellt.

GetType()

Ermittelt die Attribute eines Klassenkonstruktors und bietet Zugriff auf Metadaten des Konstruktors.

(Geerbt von ConstructorInfo)
HasSameMetadataDefinitionAs(MemberInfo) (Geerbt von MemberInfo)
Invoke(BindingFlags, Binder, Object[], CultureInfo)

Ruft den durch diese Instanz dargestellten Konstruktor für das angegebene Objekt dynamisch auf und übergibt dabei die angegebenen Parameter unter den Einschränkungen des angegebenen Binders.

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

Ruft bei der Implementierung in einer abgeleiteten Klasse den von dieser ConstructorInfo reflektierten Konstruktor mit den angegebenen Argumenten und gemäß den Einschränkungen des angegebenen Binder auf.

(Geerbt von ConstructorInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)

Ruft den Konstruktor, der von dieser Instanz reflektiert wird, mit den angegebenen Argumenten gemäß den Einschränkung des angegebenen Binder-Elements dynamisch ab.

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

Ruft beim Überschreiben in einer abgeleiteten Klasse die reflektierte Methode oder den reflektierten Konstruktor mit den angegebenen Parametern auf.

(Geerbt von MethodBase)
Invoke(Object, Object[])

Ruft die Methode oder den Konstruktor, die/der durch die aktuelle Instanz dargestellt wird, mit den angegebenen Parametern auf.

(Geerbt von MethodBase)
Invoke(Object[])

Ruft den Konstruktor auf, der von der Instanz reflektiert wird, die über die angegebenen Parameter verfügt, und stellt damit Standardwerte für die nicht häufig verwendeten Parameter bereit.

(Geerbt von ConstructorInfo)
IsDefined(Type, Boolean)

Überprüft, ob der Typ des angegebenen benutzerdefinierten Attributs definiert ist.

IsDefined(Type, Boolean)

Gibt beim Überschreiben in einer abgeleiteten Klasse an, ob ein oder mehrere Attribute des angegebenen Typs oder seiner abgeleiteten Typen auf diesen Member angewendet werden.

(Geerbt von MemberInfo)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
SetCustomAttribute(ConstructorInfo, Byte[])

Legt ein benutzerdefiniertes Attribut mithilfe eines angegebenen benutzerdefinierten Attribut-BLOBs fest.

SetCustomAttribute(CustomAttributeBuilder)

Legt ein benutzerdefiniertes Attribut mithilfe eines benutzerdefinierten Attribut-Generators fest.

SetImplementationFlags(MethodImplAttributes)

Legt die Methodenimplementierungsflags für diesen Konstruktor fest.

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

Erstellt den Text des Konstruktors unter Verwendung eines angegebenen Bytearrays von MSIL-Anweisungen (Microsoft Intermediate Language).

SetSymCustomAttribute(String, Byte[])

Legt das benutzerdefinierte Attribut dieses Konstruktors fest, das Symbolinformationen zugeordnet ist.

ToString()

Gibt diese ConstructorBuilder-Instanz als String zurück.

ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)

Explizite Schnittstellenimplementierungen

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

Ordnet eine Reihe von Namen einer entsprechenden Reihe von Dispatchbezeichnern zu.

_ConstructorBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)

Ruft die Typinformationen für ein Objekt ab, die dann zum Abrufen der Typinformationen für eine Schnittstelle verwendet werden können.

_ConstructorBuilder.GetTypeInfoCount(UInt32)

Ruft die Anzahl der Schnittstellen mit Typinformationen ab, die von einem Objekt bereitgestellt werden (0 oder 1).

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

Stellt den Zugriff auf von einem Objekt verfügbar gemachte Eigenschaften und Methoden bereit.

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

Ordnet eine Reihe von Namen einer entsprechenden Reihe von Dispatchbezeichnern zu.

(Geerbt von ConstructorInfo)
_ConstructorInfo.GetType()

Ruft ein Type-Objekt ab, das den ConstructorInfo-Typ darstellt.

(Geerbt von ConstructorInfo)
_ConstructorInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Ruft die Typinformationen für ein Objekt ab, die dann zum Abrufen der Typinformationen für eine Schnittstelle verwendet werden können.

(Geerbt von ConstructorInfo)
_ConstructorInfo.GetTypeInfoCount(UInt32)

Ruft die Anzahl der Schnittstellen mit Typinformationen ab, die von einem Objekt bereitgestellt werden (0 oder 1).

(Geerbt von ConstructorInfo)
_ConstructorInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Stellt den Zugriff auf von einem Objekt verfügbar gemachte Eigenschaften und Methoden bereit.

(Geerbt von ConstructorInfo)
_ConstructorInfo.Invoke_2(Object, BindingFlags, Binder, Object[], CultureInfo)

Stellt einen versionsunabhängigen Zugriff auf die Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)-Methode für COM-Objekte bereit.

(Geerbt von ConstructorInfo)
_ConstructorInfo.Invoke_3(Object, Object[])

Stellt einen versionsunabhängigen Zugriff auf die Invoke(Object, Object[])-Methode für COM-Objekte bereit.

(Geerbt von ConstructorInfo)
_ConstructorInfo.Invoke_4(BindingFlags, Binder, Object[], CultureInfo)

Stellt einen versionsunabhängigen Zugriff auf die Invoke(BindingFlags, Binder, Object[], CultureInfo)-Methode für COM-Objekte bereit.

(Geerbt von ConstructorInfo)
_ConstructorInfo.Invoke_5(Object[])

Stellt einen versionsunabhängigen Zugriff auf die Invoke(Object[])-Methode für COM-Objekte bereit.

(Geerbt von ConstructorInfo)
_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Ordnet eine Reihe von Namen einer entsprechenden Reihe von Dispatchbezeichnern zu.

(Geerbt von MemberInfo)
_MemberInfo.GetType()

Ruft ein Type-Objekt ab, das die MemberInfo-Klasse darstellt.

(Geerbt von MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Ruft die Typinformationen für ein Objekt ab, die dann zum Abrufen der Typinformationen für eine Schnittstelle verwendet werden können.

(Geerbt von MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

Ruft die Anzahl der Schnittstellen mit Typinformationen ab, die von einem Objekt bereitgestellt werden (0 oder 1).

(Geerbt von MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Stellt den Zugriff auf von einem Objekt verfügbar gemachte Eigenschaften und Methoden bereit.

(Geerbt von MemberInfo)
_MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Ordnet eine Reihe von Namen einer entsprechenden Reihe von Dispatchbezeichnern zu.

(Geerbt von MethodBase)
_MethodBase.GetType()

Eine Beschreibung dieses Elements finden Sie unter GetType().

(Geerbt von MethodBase)
_MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr)

Ruft die Typinformationen für ein Objekt ab, die dann zum Abrufen der Typinformationen für eine Schnittstelle verwendet werden können.

(Geerbt von MethodBase)
_MethodBase.GetTypeInfoCount(UInt32)

Ruft die Anzahl der Schnittstellen mit Typinformationen ab, die von einem Objekt bereitgestellt werden (0 oder 1).

(Geerbt von MethodBase)
_MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Stellt den Zugriff auf von einem Objekt verfügbar gemachte Eigenschaften und Methoden bereit.

(Geerbt von MethodBase)
_MethodBase.IsAbstract

Eine Beschreibung dieses Elements finden Sie unter IsAbstract.

(Geerbt von MethodBase)
_MethodBase.IsAssembly

Eine Beschreibung dieses Elements finden Sie unter IsAssembly.

(Geerbt von MethodBase)
_MethodBase.IsConstructor

Eine Beschreibung dieses Elements finden Sie unter IsConstructor.

(Geerbt von MethodBase)
_MethodBase.IsFamily

Eine Beschreibung dieses Elements finden Sie unter IsFamily.

(Geerbt von MethodBase)
_MethodBase.IsFamilyAndAssembly

Eine Beschreibung dieses Elements finden Sie unter IsFamilyAndAssembly.

(Geerbt von MethodBase)
_MethodBase.IsFamilyOrAssembly

Eine Beschreibung dieses Elements finden Sie unter IsFamilyOrAssembly.

(Geerbt von MethodBase)
_MethodBase.IsFinal

Eine Beschreibung dieses Elements finden Sie unter IsFinal.

(Geerbt von MethodBase)
_MethodBase.IsHideBySig

Eine Beschreibung dieses Elements finden Sie unter IsHideBySig.

(Geerbt von MethodBase)
_MethodBase.IsPrivate

Eine Beschreibung dieses Elements finden Sie unter IsPrivate.

(Geerbt von MethodBase)
_MethodBase.IsPublic

Eine Beschreibung dieses Elements finden Sie unter IsPublic.

(Geerbt von MethodBase)
_MethodBase.IsSpecialName

Eine Beschreibung dieses Elements finden Sie unter IsSpecialName.

(Geerbt von MethodBase)
_MethodBase.IsStatic

Eine Beschreibung dieses Elements finden Sie unter IsStatic.

(Geerbt von MethodBase)
_MethodBase.IsVirtual

Eine Beschreibung dieses Elements finden Sie unter IsVirtual.

(Geerbt von MethodBase)
ICustomAttributeProvider.GetCustomAttributes(Boolean)

Gibt – mit Ausnahme benannter Attribute – ein Array mit allen für diesen Member definierten benutzerdefinierten Attributen zurück – oder ein leeres Array , wenn keine benutzerdefinierten Attribute vorhanden sind.

(Geerbt von MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)

Gibt ein Array mit für diesen Member definierten benutzerdefinierten Attributen zurück – identifiziert nach Typ – oder ein leeres Array , wenn keine benutzerdefinierten Attribute vorhanden sind.

(Geerbt von MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean)

Gibt an, ob mindestens eine Instanz von attributeType für diesen Member definiert ist.

(Geerbt von MemberInfo)

Erweiterungsmethoden

GetCustomAttribute(MemberInfo, Type)

Ruft ein benutzerdefiniertes Attribut eines angegebenen Typs ab, der für einen angegebenen Member angewendet wird.

GetCustomAttribute(MemberInfo, Type, Boolean)

Ruft ein benutzerdefiniertes Attribut eines angegebenen Typs ab, der für einen angegebenen Member angewendet wird, und überprüft optional die Vorgänger dieses Members.

GetCustomAttribute<T>(MemberInfo)

Ruft ein benutzerdefiniertes Attribut eines angegebenen Typs ab, der für einen angegebenen Member angewendet wird.

GetCustomAttribute<T>(MemberInfo, Boolean)

Ruft ein benutzerdefiniertes Attribut eines angegebenen Typs ab, der für einen angegebenen Member angewendet wird, und überprüft optional die Vorgänger dieses Members.

GetCustomAttributes(MemberInfo)

Ruft eine Auflistung benutzerdefinierter Attribute ab, die für einen angegebenen Member angewendet werden.

GetCustomAttributes(MemberInfo, Boolean)

Ruft eine Auflistung benutzerdefinierter Attribute ab, die für einen angegebenen Member angewendet werden, und überprüft optional die Vorgänger dieses Members.

GetCustomAttributes(MemberInfo, Type)

Ruft eine Auflistung benutzerdefinierter Attribute eines angegebenen Typs ab, die für eine angegebenen Member angewendet werden.

GetCustomAttributes(MemberInfo, Type, Boolean)

Ruft eine Auflistung benutzerdefinierter Attribute eines angegebenen Typs ab, die für einen angegebenen Member angewendet werden, und überprüft optional die Vorgänger dieses Members.

GetCustomAttributes<T>(MemberInfo)

Ruft eine Auflistung benutzerdefinierter Attribute eines angegebenen Typs ab, die für eine angegebenen Member angewendet werden.

GetCustomAttributes<T>(MemberInfo, Boolean)

Ruft eine Auflistung benutzerdefinierter Attribute eines angegebenen Typs ab, die für einen angegebenen Member angewendet werden, und überprüft optional die Vorgänger dieses Members.

IsDefined(MemberInfo, Type)

Gibt an, ob irgend welche benutzerdefinierten Attribute eines bestimmten Typs auf eines angegebenen Members angewendet werden.

IsDefined(MemberInfo, Type, Boolean)

Gibt an, ob benutzerdefinierte Attribute eines angegebenen Typs auf einen angegebenen Member und optional auf dessen Vorgänger angewendet werden.

GetMetadataToken(MemberInfo)

Ruft ein Metadatentoken für das angegebene Element ab, falls verfügbar.

HasMetadataToken(MemberInfo)

Gibt einen Wert zurück, der angibt, ob ein Metadatentoken für das angegebene Element verfügbar ist.

Gilt für: