ConstructorBuilder Třída
Definice
Důležité
Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.
Definuje a představuje konstruktor dynamické třídy.
public ref class ConstructorBuilder sealed : System::Reflection::ConstructorInfo
public ref class ConstructorBuilder abstract : System::Reflection::ConstructorInfo
public ref class ConstructorBuilder sealed : System::Reflection::ConstructorInfo, System::Runtime::InteropServices::_ConstructorBuilder
public sealed class ConstructorBuilder : System.Reflection.ConstructorInfo
public abstract 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
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 MustInherit Class ConstructorBuilder
Inherits ConstructorInfo
Public NotInheritable Class ConstructorBuilder
Inherits ConstructorInfo
Implements _ConstructorBuilder
- Dědičnost
- Atributy
- Implementuje
Příklady
Následující ukázka kódu znázorňuje kontextové použití objektu 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 se používá k úplnému popisu konstruktoru v microsoft intermediate language (MSIL), včetně názvu, atributů, podpisu a textu konstruktoru. Používá se ve spojení s TypeBuilder třídou k vytváření tříd za běhu. Voláním DefineConstructor získáte instanci .ConstructorBuilder
Pokud nedefinujete konstruktor pro dynamický typ, je automaticky zadán konstruktor bez parametrů a volá konstruktor bez parametrů základní třídy.
Pokud použijete ConstructorBuilder k definování konstruktoru pro dynamický typ, není k dispozici konstruktor bez parametrů. Kromě konstruktoru, který jste definovali, máte k dispozici následující možnosti, jak poskytnout konstruktor bez parametrů:
Pokud chcete konstruktor bez parametrů, který jednoduše volá konstruktor bez parametrů základní třídy, můžete použít metodu TypeBuilder.DefineDefaultConstructor k jeho vytvoření (a volitelně k němu omezit přístup). Neposkytujte implementaci pro tento konstruktor bez parametrů. Pokud ano, při pokusu o použití konstruktoru dojde k výjimce. Při TypeBuilder.CreateType zavolání metody není vyvolána žádná výjimka.
Pokud chcete konstruktor bez parametrů, který dělá něco víc než jen volání konstruktoru bez parametrů základní třídy, nebo který volá jiný konstruktor základní třídy, nebo který dělá něco úplně jiného, musíte použít metodu TypeBuilder.DefineConstructorConstructorBuilderk vytvoření a poskytnutí vlastní implementace.
Konstruktory
ConstructorBuilder() |
Inicializuje novou instanci ConstructorBuilder třídy. |
Vlastnosti
Attributes |
Získá atributy pro tento konstruktor. |
CallingConvention |
CallingConventions Získá hodnotu, která závisí na tom, zda deklarující typ je obecný. |
CallingConvention |
Získá hodnotu označující konvence volání pro tuto metodu. (Zděděno od MethodBase) |
ContainsGenericParameters |
Získá hodnotu označující, zda obecná metoda obsahuje nepřiřazené parametry obecného typu. (Zděděno od MethodBase) |
CustomAttributes |
Získá kolekci, která obsahuje vlastní atributy tohoto člena. (Zděděno od MemberInfo) |
DeclaringType |
Získá odkaz na Type objekt pro typ, který deklaruje tento člen. |
InitLocals |
Získá nebo nastaví, zda místní proměnné v tomto konstruktoru by měly být inicializovány nula. |
InitLocalsCore |
Při přepsání v odvozené třídě získá nebo nastaví hodnotu, která označuje, zda místní proměnné v tomto konstruktoru mají být inicializovány nula. |
IsAbstract |
Získá hodnotu označující, zda je metoda abstraktní. (Zděděno od MethodBase) |
IsAssembly |
Získá hodnotu označující, zda potenciální viditelnost této metody nebo konstruktoru je popsána ; Assemblyto znamená, že metoda nebo konstruktor je viditelný maximálně pro jiné typy ve stejném sestavení a není viditelný pro odvozené typy mimo sestavení. (Zděděno od MethodBase) |
IsCollectible |
Získá hodnotu, která označuje, zda je tento MemberInfo objekt součástí sestavení uchovávaného v collectible AssemblyLoadContext. (Zděděno od MemberInfo) |
IsConstructedGenericMethod |
Definuje a představuje konstruktor dynamické třídy. (Zděděno od MethodBase) |
IsConstructor |
Získá hodnotu označující, zda je metoda konstruktor. (Zděděno od MethodBase) |
IsFamily |
Získá hodnotu označující, zda viditelnost této metody nebo konstruktoru je popsána ; Familyto znamená, že metoda nebo konstruktor je viditelný pouze v rámci své třídy a odvozené třídy. (Zděděno od MethodBase) |
IsFamilyAndAssembly |
Získá hodnotu označující, zda viditelnost této metody nebo konstruktoru je popsána ; FamANDAssemto znamená, že metoda nebo konstruktor lze volat odvozené třídy, ale pouze pokud jsou ve stejném sestavení. (Zděděno od MethodBase) |
IsFamilyOrAssembly |
Získá hodnotu označující, zda potenciální viditelnost této metody nebo konstruktoru je popsána ; FamORAssemto znamená, že metoda nebo konstruktor lze volat odvozené třídy bez ohledu na to, kde jsou, a třídy ve stejném sestavení. (Zděděno od MethodBase) |
IsFinal |
Získá hodnotu označující, zda je |
IsGenericMethod |
Získá hodnotu označující, zda je metoda obecná. (Zděděno od MethodBase) |
IsGenericMethodDefinition |
Získá hodnotu označující, zda metoda je obecná definice metody. (Zděděno od MethodBase) |
IsHideBySig |
Získá hodnotu označující, zda je v odvozené třídě skrytý pouze člen stejného typu s přesně stejným podpisem. (Zděděno od MethodBase) |
IsPrivate |
Získá hodnotu označující, zda je tento člen soukromý. (Zděděno od MethodBase) |
IsPublic |
Získá hodnotu označující, zda se jedná o veřejnou metodu. (Zděděno od MethodBase) |
IsSecurityCritical |
Získá hodnotu, která označuje, zda aktuální metoda nebo konstruktor je na aktuální úrovni důvěryhodnosti kritický nebo bezpečný-kritický na úrovni zabezpečení, a proto může provádět kritické operace. (Zděděno od MethodBase) |
IsSecuritySafeCritical |
Získá hodnotu, která označuje, zda aktuální metoda nebo konstruktor je zabezpečení-kritické na aktuální úrovni důvěryhodnosti; to znamená, jestli může provádět kritické operace a může být přístupný transparentním kódem. (Zděděno od MethodBase) |
IsSecurityTransparent |
Získá hodnotu, která označuje, zda aktuální metoda nebo konstruktor je transparentní na aktuální úrovni důvěryhodnosti, a proto nemůže provádět kritické operace. (Zděděno od MethodBase) |
IsSpecialName |
Získá hodnotu označující, zda tato metoda má zvláštní název. (Zděděno od MethodBase) |
IsStatic |
Získá hodnotu označující, zda je |
IsVirtual |
Získá hodnotu označující, zda je |
MemberType |
MemberTypes Získá hodnotu označující, že tento člen je konstruktor. (Zděděno od ConstructorInfo) |
MetadataToken |
Získá token, který identifikuje aktuální dynamický modul v metadatech. |
MetadataToken |
Získá hodnotu, která identifikuje metadata element. (Zděděno od MemberInfo) |
MethodHandle |
Získá interní popisovač pro metodu. Tento popisovač použijte pro přístup k podkladovému popisovači metadat. |
MethodHandle |
Získá popisovač k reprezentaci interních metadat metody. (Zděděno od MethodBase) |
MethodImplementationFlags |
MethodImplAttributes Získá příznaky, které určují atributy implementace metody. |
MethodImplementationFlags |
MethodImplAttributes Získá příznaky, které určují atributy implementace metody. (Zděděno od MethodBase) |
Module |
Získá dynamický modul, ve kterém je definován tento konstruktor. |
Module |
Získá modul, ve kterém typ, který deklaruje člen reprezentovaný aktuální MemberInfo je definován. (Zděděno od MemberInfo) |
Name |
Načte název tohoto konstruktoru. |
ReflectedType |
Obsahuje odkaz na Type objekt, ze kterého byl tento objekt získán. |
ReflectedType |
Získá objekt třídy, který byl použit k získání této instance . |
ReturnType |
Zastaralé.
Získá |
Signature |
Načte podpis pole ve formě řetězce. |
Metody
AddDeclarativeSecurity(SecurityAction, PermissionSet) |
Přidá do tohoto konstruktoru deklarativní zabezpečení. |
DefineParameter(Int32, ParameterAttributes, String) |
Definuje parametr tohoto konstruktoru. |
DefineParameterCore(Int32, ParameterAttributes, String) |
Při přepsání v odvozené třídě definuje parametr tohoto konstruktoru. |
Equals(Object) |
Vrací hodnotu, která určuje, zda je tato instance rovna zadanému objektu. (Zděděno od ConstructorInfo) |
GetCustomAttributes(Boolean) |
Vrátí všechny vlastní atributy definované pro tento konstruktor. |
GetCustomAttributes(Boolean) |
Při přepsání v odvozené třídě vrátí pole všech vlastních atributů použitých pro tento člen. (Zděděno od MemberInfo) |
GetCustomAttributes(Type, Boolean) |
Vrátí vlastní atributy identifikované daným typem. |
GetCustomAttributes(Type, Boolean) |
Při přepsání v odvozené třídě vrátí pole vlastních atributů použitých na tohoto člena a identifikovaných pomocí Type. (Zděděno od MemberInfo) |
GetCustomAttributesData() |
Vrátí seznam CustomAttributeData objektů představujících data o atributech, které byly použity na cílového člena. (Zděděno od MemberInfo) |
GetGenericArguments() |
Vrátí pole Type objektů, které představují argumenty typu obecné metody nebo parametry typu definice obecné metody. (Zděděno od MethodBase) |
GetHashCode() |
Vrátí hodnotu hash pro tuto instanci. (Zděděno od ConstructorInfo) |
GetILGenerator() |
Získá pro ILGenerator tento konstruktor. |
GetILGenerator(Int32) |
ILGenerator Získá objekt se zadanou velikostí msIL streamu, který lze použít k sestavení těla metody pro tento konstruktor. |
GetILGeneratorCore(Int32) |
Při přepsání v odvozené třídě získá objekt ILGenerator , který lze použít k vygenerování těla metody pro tento konstruktor. |
GetMethodBody() |
Při přepsání v odvozené třídě získá MethodBody objekt, který poskytuje přístup k msil stream, místní proměnné a výjimky pro aktuální metodu. (Zděděno od MethodBase) |
GetMethodImplementationFlags() |
Vrátí příznaky implementace metody pro tento konstruktor. |
GetMethodImplementationFlags() |
Při přepsání v odvozené třídě vrátí MethodImplAttributes příznaky. (Zděděno od MethodBase) |
GetModule() |
Vrátí odkaz na modul, který obsahuje tento konstruktor. |
GetParameters() |
Vrátí parametry tohoto konstruktoru. |
GetToken() |
Vrátí token MethodToken pro tento konstruktor. |
GetType() |
Zjistí atributy konstruktoru třídy a poskytuje přístup k metadatům konstruktoru. (Zděděno od ConstructorInfo) |
HasSameMetadataDefinitionAs(MemberInfo) |
Definuje a představuje konstruktor dynamické třídy. (Zděděno od MemberInfo) |
Invoke(BindingFlags, Binder, Object[], CultureInfo) |
Dynamicky vyvolá konstruktor reprezentovaný touto instancí na daném objektu, předává zadané parametry a pod omezeními daného pořadače. |
Invoke(BindingFlags, Binder, Object[], CultureInfo) |
Při implementaci v odvozené třídě vyvolá konstruktor, který se tím |
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) |
Dynamicky vyvolá konstruktor reflektovaný touto instancí se zadanými argumenty v rámci omezení zadaného |
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) |
Při přepsání v odvozené třídě vyvolá odraženou metodu nebo konstruktor s danými parametry. (Zděděno od MethodBase) |
Invoke(Object, Object[]) |
Vyvolá metodu nebo konstruktor reprezentovaný aktuální instancí pomocí zadaných parametrů. (Zděděno od MethodBase) |
Invoke(Object[]) |
Vyvolá konstruktor odrážející instanci, která má zadané parametry, a poskytne výchozí hodnoty pro parametry, které se běžně nepoužívají. (Zděděno od ConstructorInfo) |
IsDefined(Type, Boolean) |
Zkontroluje, jestli je definovaný typ vlastního atributu. |
IsDefined(Type, Boolean) |
Při přepsání v odvozené třídě označuje, zda jeden nebo více atributů zadaného typu nebo jeho odvozených typů je použit na tohoto člena. (Zděděno od MemberInfo) |
MemberwiseClone() |
Vytvoří mělkou kopii aktuálního Objectsouboru . (Zděděno od Object) |
SetCustomAttribute(ConstructorInfo, Byte[]) |
Nastavte vlastní atribut pomocí zadaného objektu blob vlastního atributu. |
SetCustomAttribute(CustomAttributeBuilder) |
Nastavte vlastní atribut pomocí vlastního tvůrce atributů. |
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>) |
Při přepsání v odvozené třídě nastaví vlastní atribut v tomto konstruktoru. |
SetImplementationFlags(MethodImplAttributes) |
Nastaví příznaky implementace metody pro tento konstruktor. |
SetImplementationFlagsCore(MethodImplAttributes) |
Při přepsání v odvozené třídě nastaví příznaky implementace metody pro tento konstruktor. |
SetMethodBody(Byte[], Int32, Byte[], IEnumerable<ExceptionHandler>, IEnumerable<Int32>) |
Vytvoří tělo konstruktoru pomocí zadaného pole bajtů instrukcí jazyka MSIL (Microsoft Intermediate Language). |
SetSymCustomAttribute(String, Byte[]) |
Nastaví vlastní atribut tohoto konstruktoru přidružený k symbolickým informacím. |
ToString() |
Vrátí tuto ConstructorBuilder instanci jako 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í. |
_ConstructorBuilder.GetTypeInfo(UInt32, UInt32, IntPtr) |
Načte informace o typu objektu, který lze použít k získání informací o typu pro rozhraní. |
_ConstructorBuilder.GetTypeInfoCount(UInt32) |
Získá počet rozhraní typu informací, které objekt poskytuje (0 nebo 1). |
_ConstructorBuilder.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) |
Poskytuje přístup k vlastnostem a metodám vystaveným objektem. |
_ConstructorInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) |
Mapuje sadu názvů na odpovídající sadu identifikátorů pro rozesílání. (Zděděno od ConstructorInfo) |
_ConstructorInfo.GetType() |
Type Získá objekt představující ConstructorInfo typ. (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í. (Zděděno od ConstructorInfo) |
_ConstructorInfo.GetTypeInfoCount(UInt32) |
Získá počet rozhraní typu informací, které objekt poskytuje (0 nebo 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. (Zděděno od ConstructorInfo) |
_ConstructorInfo.Invoke_2(Object, BindingFlags, Binder, Object[], CultureInfo) |
Poskytuje objekty COM s přístupem k metodě nezávislý na verzích Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) . (Zděděno od ConstructorInfo) |
_ConstructorInfo.Invoke_3(Object, Object[]) |
Poskytuje objekty COM s přístupem k metodě nezávislý na verzích Invoke(Object, Object[]) . (Zděděno od ConstructorInfo) |
_ConstructorInfo.Invoke_4(BindingFlags, Binder, Object[], CultureInfo) |
Poskytuje objekty COM s přístupem k metodě nezávislý na verzích Invoke(BindingFlags, Binder, Object[], CultureInfo) . (Zděděno od ConstructorInfo) |
_ConstructorInfo.Invoke_5(Object[]) |
Poskytuje objekty COM s přístupem k metodě nezávislý na verzích Invoke(Object[]) . (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í. (Zděděno od MemberInfo) |
_MemberInfo.GetType() |
Type Získá objekt představující MemberInfo třídu. (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í. (Zděděno od MemberInfo) |
_MemberInfo.GetTypeInfoCount(UInt32) |
Získá počet rozhraní typu informací, které objekt poskytuje (0 nebo 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. (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í. (Zděděno od MethodBase) |
_MethodBase.GetType() |
Popis tohoto člena najdete v tématu 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í. (Zděděno od MethodBase) |
_MethodBase.GetTypeInfoCount(UInt32) |
Získá počet rozhraní typu informací, které objekt poskytuje (0 nebo 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. (Zděděno od MethodBase) |
_MethodBase.IsAbstract |
Popis tohoto člena najdete v tématu IsAbstract. (Zděděno od MethodBase) |
_MethodBase.IsAssembly |
Popis tohoto člena najdete v tématu IsAssembly. (Zděděno od MethodBase) |
_MethodBase.IsConstructor |
Popis tohoto člena najdete v tématu IsConstructor. (Zděděno od MethodBase) |
_MethodBase.IsFamily |
Popis tohoto člena najdete v tématu IsFamily. (Zděděno od MethodBase) |
_MethodBase.IsFamilyAndAssembly |
Popis tohoto člena najdete v tématu IsFamilyAndAssembly. (Zděděno od MethodBase) |
_MethodBase.IsFamilyOrAssembly |
Popis tohoto člena najdete v tématu IsFamilyOrAssembly. (Zděděno od MethodBase) |
_MethodBase.IsFinal |
Popis tohoto člena najdete v tématu IsFinal. (Zděděno od MethodBase) |
_MethodBase.IsHideBySig |
Popis tohoto člena najdete v tématu IsHideBySig. (Zděděno od MethodBase) |
_MethodBase.IsPrivate |
Popis tohoto člena najdete v tématu IsPrivate. (Zděděno od MethodBase) |
_MethodBase.IsPublic |
Popis tohoto člena najdete v tématu IsPublic. (Zděděno od MethodBase) |
_MethodBase.IsSpecialName |
Popis tohoto člena najdete v tématu IsSpecialName. (Zděděno od MethodBase) |
_MethodBase.IsStatic |
Popis tohoto člena najdete v tématu IsStatic. (Zděděno od MethodBase) |
_MethodBase.IsVirtual |
Popis tohoto člena najdete v tématu IsVirtual. (Zděděno od MethodBase) |
ICustomAttributeProvider.GetCustomAttributes(Boolean) |
Vrátí pole všech vlastních atributů definovaných v tomto členu, s výjimkou pojmenovaných atributů, nebo prázdné pole, pokud neexistují žádné vlastní atributy. (Zděděno od MemberInfo) |
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean) |
Vrátí pole vlastních atributů definovaných na tomto členu, které jsou identifikovány typem, nebo prázdné pole, pokud neexistují žádné vlastní atributy tohoto typu. (Zděděno od MemberInfo) |
ICustomAttributeProvider.IsDefined(Type, Boolean) |
Určuje, zda je u tohoto člena |
Metody rozšíření
GetCustomAttribute(MemberInfo, Type) |
Načte vlastní atribut zadaného typu, který je použit na zadaného člena. |
GetCustomAttribute(MemberInfo, Type, Boolean) |
Načte vlastní atribut zadaného typu, který je použit na zadaného člena, a volitelně zkontroluje předchůdce tohoto člena. |
GetCustomAttribute<T>(MemberInfo) |
Načte vlastní atribut zadaného typu, který je použit na zadaného člena. |
GetCustomAttribute<T>(MemberInfo, Boolean) |
Načte vlastní atribut zadaného typu, který je použit na zadaného člena, a volitelně zkontroluje předchůdce tohoto člena. |
GetCustomAttributes(MemberInfo) |
Načte kolekci vlastních atributů, které jsou použity na zadaného člena. |
GetCustomAttributes(MemberInfo, Boolean) |
Načte kolekci vlastních atributů, které jsou použity na zadaného člena, a volitelně zkontroluje předky tohoto člena. |
GetCustomAttributes(MemberInfo, Type) |
Načte kolekci vlastních atributů zadaného typu, které jsou použity na zadaného člena. |
GetCustomAttributes(MemberInfo, Type, Boolean) |
Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaného člena, a volitelně zkontroluje předky tohoto člena. |
GetCustomAttributes<T>(MemberInfo) |
Načte kolekci vlastních atributů zadaného typu, které jsou použity na zadaného člena. |
GetCustomAttributes<T>(MemberInfo, Boolean) |
Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaného člena, a volitelně zkontroluje předky tohoto člena. |
IsDefined(MemberInfo, Type) |
Určuje, zda jsou na zadaného člena použity vlastní atributy zadaného typu. |
IsDefined(MemberInfo, Type, Boolean) |
Určuje, zda se vlastní atributy zadaného typu použijí na zadaného člena a volitelně se použijí na jeho předky. |
GetMetadataToken(MemberInfo) |
Získá token metadat pro daného člena, pokud je k dispozici. |
HasMetadataToken(MemberInfo) |
Vrátí hodnotu, která označuje, zda je token metadat k dispozici pro zadaného člena. |
Platí pro
Váš názor
https://aka.ms/ContentUserFeedback.
Připravujeme: V průběhu roku 2024 budeme postupně vyřazovat problémy z GitHub coby mechanismus zpětné vazby pro obsah a nahrazovat ho novým systémem zpětné vazby. Další informace naleznete v tématu:Odeslat a zobrazit názory pro