TypeBuilder Klasa
Definicja
Ważne
Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania.
public ref class TypeBuilder sealed : Type
public ref class TypeBuilder sealed : System::Reflection::TypeInfo
public ref class TypeBuilder abstract : System::Reflection::TypeInfo
public ref class TypeBuilder sealed : Type, System::Runtime::InteropServices::_TypeBuilder
public ref class TypeBuilder sealed : System::Reflection::TypeInfo, System::Runtime::InteropServices::_TypeBuilder
public sealed class TypeBuilder : Type
public sealed class TypeBuilder : System.Reflection.TypeInfo
public abstract class TypeBuilder : System.Reflection.TypeInfo
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
public sealed class TypeBuilder : Type, System.Runtime.InteropServices._TypeBuilder
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class TypeBuilder : Type, System.Runtime.InteropServices._TypeBuilder
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class TypeBuilder : System.Reflection.TypeInfo, System.Runtime.InteropServices._TypeBuilder
type TypeBuilder = class
inherit Type
type TypeBuilder = class
inherit TypeInfo
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
type TypeBuilder = class
inherit Type
interface _TypeBuilder
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type TypeBuilder = class
inherit Type
interface _TypeBuilder
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type TypeBuilder = class
inherit TypeInfo
interface _TypeBuilder
Public NotInheritable Class TypeBuilder
Inherits Type
Public NotInheritable Class TypeBuilder
Inherits TypeInfo
Public MustInherit Class TypeBuilder
Inherits TypeInfo
Public NotInheritable Class TypeBuilder
Inherits Type
Implements _TypeBuilder
Public NotInheritable Class TypeBuilder
Inherits TypeInfo
Implements _TypeBuilder
- Dziedziczenie
- Dziedziczenie
- Dziedziczenie
- Atrybuty
- Implementuje
Przykłady
Poniższy przykład kodu przedstawia sposób definiowania i używania zestawu dynamicznego. Przykładowy zestaw zawiera jeden typ, MyDynamicType
, który ma pole prywatne, właściwość, która pobiera i ustawia pole prywatne, konstruktory, które inicjują pole prywatne, oraz metodę, która mnoży liczbę dostarczaną przez użytkownika przez wartość pola prywatnego i zwraca wynik.
using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
void main()
{
// This code creates an assembly that contains one type,
// named "MyDynamicType", that has a private field, a property
// that gets and sets the private field, constructors that
// initialize the private field, and a method that multiplies
// a user-supplied number by the private field value and returns
// the result. In Visual C++ the type might look like this:
/*
public ref class MyDynamicType
{
private:
int m_number;
public:
MyDynamicType() : m_number(42) {};
MyDynamicType(int initNumber) : m_number(initNumber) {};
property int Number
{
int get() { return m_number; }
void set(int value) { m_number = value; }
}
int MyMethod(int multiplier)
{
return m_number * multiplier;
}
};
*/
AssemblyName^ aName = gcnew AssemblyName("DynamicAssemblyExample");
AssemblyBuilder^ ab =
AssemblyBuilder::DefineDynamicAssembly(
aName,
AssemblyBuilderAccess::Run);
// The module name is usually the same as the assembly name
ModuleBuilder^ mb =
ab->DefineDynamicModule(aName->Name);
TypeBuilder^ tb = mb->DefineType(
"MyDynamicType",
TypeAttributes::Public);
// Add a private field of type int (Int32).
FieldBuilder^ fbNumber = tb->DefineField(
"m_number",
int::typeid,
FieldAttributes::Private);
// Define a constructor that takes an integer argument and
// stores it in the private field.
array<Type^>^ parameterTypes = { int::typeid };
ConstructorBuilder^ ctor1 = tb->DefineConstructor(
MethodAttributes::Public,
CallingConventions::Standard,
parameterTypes);
ILGenerator^ ctor1IL = ctor1->GetILGenerator();
// For a constructor, argument zero is a reference to the new
// instance. Push it on the stack before calling the base
// class constructor. Specify the default constructor of the
// base class (System::Object) by passing an empty array of
// types (Type::EmptyTypes) to GetConstructor.
ctor1IL->Emit(OpCodes::Ldarg_0);
ctor1IL->Emit(OpCodes::Call,
Object::typeid->GetConstructor(Type::EmptyTypes));
// Push the instance on the stack before pushing the argument
// that is to be assigned to the private field m_number.
ctor1IL->Emit(OpCodes::Ldarg_0);
ctor1IL->Emit(OpCodes::Ldarg_1);
ctor1IL->Emit(OpCodes::Stfld, fbNumber);
ctor1IL->Emit(OpCodes::Ret);
// Define a default constructor that supplies a default value
// for the private field. For parameter types, pass the empty
// array of types or pass nullptr.
ConstructorBuilder^ ctor0 = tb->DefineConstructor(
MethodAttributes::Public,
CallingConventions::Standard,
Type::EmptyTypes);
ILGenerator^ ctor0IL = ctor0->GetILGenerator();
ctor0IL->Emit(OpCodes::Ldarg_0);
ctor0IL->Emit(OpCodes::Call,
Object::typeid->GetConstructor(Type::EmptyTypes));
// For a constructor, argument zero is a reference to the new
// instance. Push it on the stack before pushing the default
// value on the stack.
ctor0IL->Emit(OpCodes::Ldarg_0);
ctor0IL->Emit(OpCodes::Ldc_I4_S, 42);
ctor0IL->Emit(OpCodes::Stfld, fbNumber);
ctor0IL->Emit(OpCodes::Ret);
// Define a property named Number that gets and sets the private
// field.
//
// The last argument of DefineProperty is nullptr, because the
// property has no parameters. (If you don't specify nullptr, you must
// specify an array of Type objects. For a parameterless property,
// use the built-in array with no elements: Type::EmptyTypes)
PropertyBuilder^ pbNumber = tb->DefineProperty(
"Number",
PropertyAttributes::HasDefault,
int::typeid,
nullptr);
// The property "set" and property "get" methods require a special
// set of attributes.
MethodAttributes getSetAttr = MethodAttributes::Public |
MethodAttributes::SpecialName | MethodAttributes::HideBySig;
// Define the "get" accessor method for Number. The method returns
// an integer and has no arguments. (Note that nullptr could be
// used instead of Types::EmptyTypes)
MethodBuilder^ mbNumberGetAccessor = tb->DefineMethod(
"get_Number",
getSetAttr,
int::typeid,
Type::EmptyTypes);
ILGenerator^ numberGetIL = mbNumberGetAccessor->GetILGenerator();
// For an instance property, argument zero is the instance. Load the
// instance, then load the private field and return, leaving the
// field value on the stack.
numberGetIL->Emit(OpCodes::Ldarg_0);
numberGetIL->Emit(OpCodes::Ldfld, fbNumber);
numberGetIL->Emit(OpCodes::Ret);
// Define the "set" accessor method for Number, which has no return
// type and takes one argument of type int (Int32).
MethodBuilder^ mbNumberSetAccessor = tb->DefineMethod(
"set_Number",
getSetAttr,
nullptr,
gcnew array<Type^> { int::typeid });
ILGenerator^ numberSetIL = mbNumberSetAccessor->GetILGenerator();
// Load the instance and then the numeric argument, then store the
// argument in the field.
numberSetIL->Emit(OpCodes::Ldarg_0);
numberSetIL->Emit(OpCodes::Ldarg_1);
numberSetIL->Emit(OpCodes::Stfld, fbNumber);
numberSetIL->Emit(OpCodes::Ret);
// Last, map the "get" and "set" accessor methods to the
// PropertyBuilder. The property is now complete.
pbNumber->SetGetMethod(mbNumberGetAccessor);
pbNumber->SetSetMethod(mbNumberSetAccessor);
// Define a method that accepts an integer argument and returns
// the product of that integer and the private field m_number. This
// time, the array of parameter types is created on the fly.
MethodBuilder^ meth = tb->DefineMethod(
"MyMethod",
MethodAttributes::Public,
int::typeid,
gcnew array<Type^> { int::typeid });
ILGenerator^ methIL = meth->GetILGenerator();
// To retrieve the private instance field, load the instance it
// belongs to (argument zero). After loading the field, load the
// argument one and then multiply. Return from the method with
// the return value (the product of the two numbers) on the
// execution stack.
methIL->Emit(OpCodes::Ldarg_0);
methIL->Emit(OpCodes::Ldfld, fbNumber);
methIL->Emit(OpCodes::Ldarg_1);
methIL->Emit(OpCodes::Mul);
methIL->Emit(OpCodes::Ret);
// Finish the type->
Type^ t = tb->CreateType();
// Because AssemblyBuilderAccess includes Run, the code can be
// executed immediately. Start by getting reflection objects for
// the method and the property.
MethodInfo^ mi = t->GetMethod("MyMethod");
PropertyInfo^ pi = t->GetProperty("Number");
// Create an instance of MyDynamicType using the default
// constructor.
Object^ o1 = Activator::CreateInstance(t);
// Display the value of the property, then change it to 127 and
// display it again. Use nullptr to indicate that the property
// has no index.
Console::WriteLine("o1->Number: {0}", pi->GetValue(o1, nullptr));
pi->SetValue(o1, 127, nullptr);
Console::WriteLine("o1->Number: {0}", pi->GetValue(o1, nullptr));
// Call MyMethod, passing 22, and display the return value, 22
// times 127. Arguments must be passed as an array, even when
// there is only one.
array<Object^>^ arguments = { 22 };
Console::WriteLine("o1->MyMethod(22): {0}",
mi->Invoke(o1, arguments));
// Create an instance of MyDynamicType using the constructor
// that specifies m_Number. The constructor is identified by
// matching the types in the argument array. In this case,
// the argument array is created on the fly. Display the
// property value.
Object^ o2 = Activator::CreateInstance(t,
gcnew array<Object^> { 5280 });
Console::WriteLine("o2->Number: {0}", pi->GetValue(o2, nullptr));
};
/* This code produces the following output:
o1->Number: 42
o1->Number: 127
o1->MyMethod(22): 2794
o2->Number: 5280
*/
using System;
using System.Reflection;
using System.Reflection.Emit;
class DemoAssemblyBuilder
{
public static void Main()
{
// This code creates an assembly that contains one type,
// named "MyDynamicType", that has a private field, a property
// that gets and sets the private field, constructors that
// initialize the private field, and a method that multiplies
// a user-supplied number by the private field value and returns
// the result. In C# the type might look like this:
/*
public class MyDynamicType
{
private int m_number;
public MyDynamicType() : this(42) {}
public MyDynamicType(int initNumber)
{
m_number = initNumber;
}
public int Number
{
get { return m_number; }
set { m_number = value; }
}
public int MyMethod(int multiplier)
{
return m_number * multiplier;
}
}
*/
var aName = new AssemblyName("DynamicAssemblyExample");
AssemblyBuilder ab =
AssemblyBuilder.DefineDynamicAssembly(
aName,
AssemblyBuilderAccess.Run);
// The module name is usually the same as the assembly name.
ModuleBuilder mb = ab.DefineDynamicModule(aName.Name ?? "DynamicAssemblyExample");
TypeBuilder tb = mb.DefineType(
"MyDynamicType",
TypeAttributes.Public);
// Add a private field of type int (Int32).
FieldBuilder fbNumber = tb.DefineField(
"m_number",
typeof(int),
FieldAttributes.Private);
// Define a constructor that takes an integer argument and
// stores it in the private field.
Type[] parameterTypes = { typeof(int) };
ConstructorBuilder ctor1 = tb.DefineConstructor(
MethodAttributes.Public,
CallingConventions.Standard,
parameterTypes);
ILGenerator ctor1IL = ctor1.GetILGenerator();
// For a constructor, argument zero is a reference to the new
// instance. Push it on the stack before calling the base
// class constructor. Specify the default constructor of the
// base class (System.Object) by passing an empty array of
// types (Type.EmptyTypes) to GetConstructor.
ctor1IL.Emit(OpCodes.Ldarg_0);
ConstructorInfo? ci = typeof(object).GetConstructor(Type.EmptyTypes);
ctor1IL.Emit(OpCodes.Call, ci!);
// Push the instance on the stack before pushing the argument
// that is to be assigned to the private field m_number.
ctor1IL.Emit(OpCodes.Ldarg_0);
ctor1IL.Emit(OpCodes.Ldarg_1);
ctor1IL.Emit(OpCodes.Stfld, fbNumber);
ctor1IL.Emit(OpCodes.Ret);
// Define a default constructor that supplies a default value
// for the private field. For parameter types, pass the empty
// array of types or pass null.
ConstructorBuilder ctor0 = tb.DefineConstructor(
MethodAttributes.Public,
CallingConventions.Standard,
Type.EmptyTypes);
ILGenerator ctor0IL = ctor0.GetILGenerator();
// For a constructor, argument zero is a reference to the new
// instance. Push it on the stack before pushing the default
// value on the stack, then call constructor ctor1.
ctor0IL.Emit(OpCodes.Ldarg_0);
ctor0IL.Emit(OpCodes.Ldc_I4_S, 42);
ctor0IL.Emit(OpCodes.Call, ctor1);
ctor0IL.Emit(OpCodes.Ret);
// Define a property named Number that gets and sets the private
// field.
//
// The last argument of DefineProperty is null, because the
// property has no parameters. (If you don't specify null, you must
// specify an array of Type objects. For a parameterless property,
// use the built-in array with no elements: Type.EmptyTypes)
PropertyBuilder pbNumber = tb.DefineProperty(
"Number",
PropertyAttributes.HasDefault,
typeof(int),
null);
// The property "set" and property "get" methods require a special
// set of attributes.
MethodAttributes getSetAttr = MethodAttributes.Public |
MethodAttributes.SpecialName | MethodAttributes.HideBySig;
// Define the "get" accessor method for Number. The method returns
// an integer and has no arguments. (Note that null could be
// used instead of Types.EmptyTypes)
MethodBuilder mbNumberGetAccessor = tb.DefineMethod(
"get_Number",
getSetAttr,
typeof(int),
Type.EmptyTypes);
ILGenerator numberGetIL = mbNumberGetAccessor.GetILGenerator();
// For an instance property, argument zero is the instance. Load the
// instance, then load the private field and return, leaving the
// field value on the stack.
numberGetIL.Emit(OpCodes.Ldarg_0);
numberGetIL.Emit(OpCodes.Ldfld, fbNumber);
numberGetIL.Emit(OpCodes.Ret);
// Define the "set" accessor method for Number, which has no return
// type and takes one argument of type int (Int32).
MethodBuilder mbNumberSetAccessor = tb.DefineMethod(
"set_Number",
getSetAttr,
null,
new Type[] { typeof(int) });
ILGenerator numberSetIL = mbNumberSetAccessor.GetILGenerator();
// Load the instance and then the numeric argument, then store the
// argument in the field.
numberSetIL.Emit(OpCodes.Ldarg_0);
numberSetIL.Emit(OpCodes.Ldarg_1);
numberSetIL.Emit(OpCodes.Stfld, fbNumber);
numberSetIL.Emit(OpCodes.Ret);
// Last, map the "get" and "set" accessor methods to the
// PropertyBuilder. The property is now complete.
pbNumber.SetGetMethod(mbNumberGetAccessor);
pbNumber.SetSetMethod(mbNumberSetAccessor);
// Define a method that accepts an integer argument and returns
// the product of that integer and the private field m_number. This
// time, the array of parameter types is created on the fly.
MethodBuilder meth = tb.DefineMethod(
"MyMethod",
MethodAttributes.Public,
typeof(int),
new Type[] { typeof(int) });
ILGenerator methIL = meth.GetILGenerator();
// To retrieve the private instance field, load the instance it
// belongs to (argument zero). After loading the field, load the
// argument one and then multiply. Return from the method with
// the return value (the product of the two numbers) on the
// execution stack.
methIL.Emit(OpCodes.Ldarg_0);
methIL.Emit(OpCodes.Ldfld, fbNumber);
methIL.Emit(OpCodes.Ldarg_1);
methIL.Emit(OpCodes.Mul);
methIL.Emit(OpCodes.Ret);
// Finish the type.
Type? t = tb.CreateType();
// Because AssemblyBuilderAccess includes Run, the code can be
// executed immediately. Start by getting reflection objects for
// the method and the property.
MethodInfo? mi = t?.GetMethod("MyMethod");
PropertyInfo? pi = t?.GetProperty("Number");
// Create an instance of MyDynamicType using the default
// constructor.
object? o1 = null;
if (t is not null)
o1 = Activator.CreateInstance(t);
// Display the value of the property, then change it to 127 and
// display it again. Use null to indicate that the property
// has no index.
Console.WriteLine("o1.Number: {0}", pi?.GetValue(o1, null));
pi?.SetValue(o1, 127, null);
Console.WriteLine("o1.Number: {0}", pi?.GetValue(o1, null));
// Call MyMethod, passing 22, and display the return value, 22
// times 127. Arguments must be passed as an array, even when
// there is only one.
object[] arguments = { 22 };
Console.WriteLine("o1.MyMethod(22): {0}",
mi?.Invoke(o1, arguments));
// Create an instance of MyDynamicType using the constructor
// that specifies m_Number. The constructor is identified by
// matching the types in the argument array. In this case,
// the argument array is created on the fly. Display the
// property value.
object? o2 = null;
if (t is not null)
o2 = Activator.CreateInstance(t, new object[] { 5280 });
Console.WriteLine("o2.Number: {0}", pi?.GetValue(o2, null));
}
}
/* This code produces the following output:
o1.Number: 42
o1.Number: 127
o1.MyMethod(22): 2794
o2.Number: 5280
*/
Imports System.Reflection
Imports System.Reflection.Emit
Class DemoAssemblyBuilder
Public Shared Sub Main()
' This code creates an assembly that contains one type,
' named "MyDynamicType", that has a private field, a property
' that gets and sets the private field, constructors that
' initialize the private field, and a method that multiplies
' a user-supplied number by the private field value and returns
' the result. The code might look like this in Visual Basic:
'
'Public Class MyDynamicType
' Private m_number As Integer
'
' Public Sub New()
' Me.New(42)
' End Sub
'
' Public Sub New(ByVal initNumber As Integer)
' m_number = initNumber
' End Sub
'
' Public Property Number As Integer
' Get
' Return m_number
' End Get
' Set
' m_Number = Value
' End Set
' End Property
'
' Public Function MyMethod(ByVal multiplier As Integer) As Integer
' Return m_Number * multiplier
' End Function
'End Class
Dim aName As New AssemblyName("DynamicAssemblyExample")
Dim ab As AssemblyBuilder = _
AssemblyBuilder.DefineDynamicAssembly( _
aName, _
AssemblyBuilderAccess.Run)
' The module name is usually the same as the assembly name.
Dim mb As ModuleBuilder = ab.DefineDynamicModule( _
aName.Name)
Dim tb As TypeBuilder = _
mb.DefineType("MyDynamicType", TypeAttributes.Public)
' Add a private field of type Integer (Int32).
Dim fbNumber As FieldBuilder = tb.DefineField( _
"m_number", _
GetType(Integer), _
FieldAttributes.Private)
' Define a constructor that takes an integer argument and
' stores it in the private field.
Dim parameterTypes() As Type = { GetType(Integer) }
Dim ctor1 As ConstructorBuilder = _
tb.DefineConstructor( _
MethodAttributes.Public, _
CallingConventions.Standard, _
parameterTypes)
Dim ctor1IL As ILGenerator = ctor1.GetILGenerator()
' For a constructor, argument zero is a reference to the new
' instance. Push it on the stack before calling the base
' class constructor. Specify the default constructor of the
' base class (System.Object) by passing an empty array of
' types (Type.EmptyTypes) to GetConstructor.
ctor1IL.Emit(OpCodes.Ldarg_0)
ctor1IL.Emit(OpCodes.Call, _
GetType(Object).GetConstructor(Type.EmptyTypes))
' Push the instance on the stack before pushing the argument
' that is to be assigned to the private field m_number.
ctor1IL.Emit(OpCodes.Ldarg_0)
ctor1IL.Emit(OpCodes.Ldarg_1)
ctor1IL.Emit(OpCodes.Stfld, fbNumber)
ctor1IL.Emit(OpCodes.Ret)
' Define a default constructor that supplies a default value
' for the private field. For parameter types, pass the empty
' array of types or pass Nothing.
Dim ctor0 As ConstructorBuilder = tb.DefineConstructor( _
MethodAttributes.Public, _
CallingConventions.Standard, _
Type.EmptyTypes)
Dim ctor0IL As ILGenerator = ctor0.GetILGenerator()
' For a constructor, argument zero is a reference to the new
' instance. Push it on the stack before pushing the default
' value on the stack, then call constructor ctor1.
ctor0IL.Emit(OpCodes.Ldarg_0)
ctor0IL.Emit(OpCodes.Ldc_I4_S, 42)
ctor0IL.Emit(OpCodes.Call, ctor1)
ctor0IL.Emit(OpCodes.Ret)
' Define a property named Number that gets and sets the private
' field.
'
' The last argument of DefineProperty is Nothing, because the
' property has no parameters. (If you don't specify Nothing, you must
' specify an array of Type objects. For a parameterless property,
' use the built-in array with no elements: Type.EmptyTypes)
Dim pbNumber As PropertyBuilder = tb.DefineProperty( _
"Number", _
PropertyAttributes.HasDefault, _
GetType(Integer), _
Nothing)
' The property Set and property Get methods require a special
' set of attributes.
Dim getSetAttr As MethodAttributes = _
MethodAttributes.Public Or MethodAttributes.SpecialName _
Or MethodAttributes.HideBySig
' Define the "get" accessor method for Number. The method returns
' an integer and has no arguments. (Note that Nothing could be
' used instead of Types.EmptyTypes)
Dim mbNumberGetAccessor As MethodBuilder = tb.DefineMethod( _
"get_Number", _
getSetAttr, _
GetType(Integer), _
Type.EmptyTypes)
Dim numberGetIL As ILGenerator = mbNumberGetAccessor.GetILGenerator()
' For an instance property, argument zero is the instance. Load the
' instance, then load the private field and return, leaving the
' field value on the stack.
numberGetIL.Emit(OpCodes.Ldarg_0)
numberGetIL.Emit(OpCodes.Ldfld, fbNumber)
numberGetIL.Emit(OpCodes.Ret)
' Define the "set" accessor method for Number, which has no return
' type and takes one argument of type Integer (Int32).
Dim mbNumberSetAccessor As MethodBuilder = _
tb.DefineMethod( _
"set_Number", _
getSetAttr, _
Nothing, _
New Type() { GetType(Integer) })
Dim numberSetIL As ILGenerator = mbNumberSetAccessor.GetILGenerator()
' Load the instance and then the numeric argument, then store the
' argument in the field.
numberSetIL.Emit(OpCodes.Ldarg_0)
numberSetIL.Emit(OpCodes.Ldarg_1)
numberSetIL.Emit(OpCodes.Stfld, fbNumber)
numberSetIL.Emit(OpCodes.Ret)
' Last, map the "get" and "set" accessor methods to the
' PropertyBuilder. The property is now complete.
pbNumber.SetGetMethod(mbNumberGetAccessor)
pbNumber.SetSetMethod(mbNumberSetAccessor)
' Define a method that accepts an integer argument and returns
' the product of that integer and the private field m_number. This
' time, the array of parameter types is created on the fly.
Dim meth As MethodBuilder = tb.DefineMethod( _
"MyMethod", _
MethodAttributes.Public, _
GetType(Integer), _
New Type() { GetType(Integer) })
Dim methIL As ILGenerator = meth.GetILGenerator()
' To retrieve the private instance field, load the instance it
' belongs to (argument zero). After loading the field, load the
' argument one and then multiply. Return from the method with
' the return value (the product of the two numbers) on the
' execution stack.
methIL.Emit(OpCodes.Ldarg_0)
methIL.Emit(OpCodes.Ldfld, fbNumber)
methIL.Emit(OpCodes.Ldarg_1)
methIL.Emit(OpCodes.Mul)
methIL.Emit(OpCodes.Ret)
' Finish the type.
Dim t As Type = tb.CreateType()
' Because AssemblyBuilderAccess includes Run, the code can be
' executed immediately. Start by getting reflection objects for
' the method and the property.
Dim mi As MethodInfo = t.GetMethod("MyMethod")
Dim pi As PropertyInfo = t.GetProperty("Number")
' Create an instance of MyDynamicType using the default
' constructor.
Dim o1 As Object = Activator.CreateInstance(t)
' Display the value of the property, then change it to 127 and
' display it again. Use Nothing to indicate that the property
' has no index.
Console.WriteLine("o1.Number: {0}", pi.GetValue(o1, Nothing))
pi.SetValue(o1, 127, Nothing)
Console.WriteLine("o1.Number: {0}", pi.GetValue(o1, Nothing))
' Call MyMethod, passing 22, and display the return value, 22
' times 127. Arguments must be passed as an array, even when
' there is only one.
Dim arguments() As Object = { 22 }
Console.WriteLine("o1.MyMethod(22): {0}", _
mi.Invoke(o1, arguments))
' Create an instance of MyDynamicType using the constructor
' that specifies m_Number. The constructor is identified by
' matching the types in the argument array. In this case,
' the argument array is created on the fly. Display the
' property value.
Dim o2 As Object = Activator.CreateInstance(t, _
New Object() { 5280 })
Console.WriteLine("o2.Number: {0}", pi.GetValue(o2, Nothing))
End Sub
End Class
' This code produces the following output:
'
'o1.Number: 42
'o1.Number: 127
'o1.MyMethod(22): 2794
'o2.Number: 5280
W poniższym przykładzie kodu pokazano, jak dynamicznie kompilować typ przy użyciu polecenia TypeBuilder
.
using namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
Type^ DynamicDotProductGen()
{
Type^ ivType = nullptr;
array<Type^>^temp0 = {int::typeid,int::typeid,int::typeid};
array<Type^>^ctorParams = temp0;
AppDomain^ myDomain = Thread::GetDomain();
AssemblyName^ myAsmName = gcnew AssemblyName;
myAsmName->Name = "IntVectorAsm";
AssemblyBuilder^ myAsmBuilder = myDomain->DefineDynamicAssembly( myAsmName, AssemblyBuilderAccess::RunAndSave );
ModuleBuilder^ IntVectorModule = myAsmBuilder->DefineDynamicModule( "IntVectorModule", "Vector.dll" );
TypeBuilder^ ivTypeBld = IntVectorModule->DefineType( "IntVector", TypeAttributes::Public );
FieldBuilder^ xField = ivTypeBld->DefineField( "x", int::typeid, FieldAttributes::Private );
FieldBuilder^ yField = ivTypeBld->DefineField( "y", int::typeid, FieldAttributes::Private );
FieldBuilder^ zField = ivTypeBld->DefineField( "z", int::typeid, FieldAttributes::Private );
Type^ objType = Type::GetType( "System.Object" );
ConstructorInfo^ objCtor = objType->GetConstructor( gcnew array<Type^>(0) );
ConstructorBuilder^ ivCtor = ivTypeBld->DefineConstructor( MethodAttributes::Public, CallingConventions::Standard, ctorParams );
ILGenerator^ ctorIL = ivCtor->GetILGenerator();
ctorIL->Emit( OpCodes::Ldarg_0 );
ctorIL->Emit( OpCodes::Call, objCtor );
ctorIL->Emit( OpCodes::Ldarg_0 );
ctorIL->Emit( OpCodes::Ldarg_1 );
ctorIL->Emit( OpCodes::Stfld, xField );
ctorIL->Emit( OpCodes::Ldarg_0 );
ctorIL->Emit( OpCodes::Ldarg_2 );
ctorIL->Emit( OpCodes::Stfld, yField );
ctorIL->Emit( OpCodes::Ldarg_0 );
ctorIL->Emit( OpCodes::Ldarg_3 );
ctorIL->Emit( OpCodes::Stfld, zField );
ctorIL->Emit( OpCodes::Ret );
// This method will find the dot product of the stored vector
// with another.
array<Type^>^temp1 = {ivTypeBld};
array<Type^>^dpParams = temp1;
// Here, you create a MethodBuilder containing the
// name, the attributes (public, static, private, and so on),
// the return type (int, in this case), and a array of Type
// indicating the type of each parameter. Since the sole parameter
// is a IntVector, the very class you're creating, you will
// pass in the TypeBuilder (which is derived from Type) instead of
// a Type object for IntVector, avoiding an exception.
// -- This method would be declared in C# as:
// public int DotProduct(IntVector aVector)
MethodBuilder^ dotProductMthd = ivTypeBld->DefineMethod( "DotProduct", MethodAttributes::Public, int::typeid, dpParams );
// A ILGenerator can now be spawned, attached to the MethodBuilder.
ILGenerator^ mthdIL = dotProductMthd->GetILGenerator();
// Here's the body of our function, in MSIL form. We're going to find the
// "dot product" of the current vector instance with the passed vector
// instance. For reference purposes, the equation is:
// (x1 * x2) + (y1 * y2) + (z1 * z2) = the dot product
// First, you'll load the reference to the current instance "this"
// stored in argument 0 (ldarg.0) onto the stack. Ldfld, the subsequent
// instruction, will pop the reference off the stack and look up the
// field "x", specified by the FieldInfo token "xField".
mthdIL->Emit( OpCodes::Ldarg_0 );
mthdIL->Emit( OpCodes::Ldfld, xField );
// That completed, the value stored at field "x" is now atop the stack.
// Now, you'll do the same for the Object reference we passed as a
// parameter, stored in argument 1 (ldarg.1). After Ldfld executed,
// you'll have the value stored in field "x" for the passed instance
// atop the stack.
mthdIL->Emit( OpCodes::Ldarg_1 );
mthdIL->Emit( OpCodes::Ldfld, xField );
// There will now be two values atop the stack - the "x" value for the
// current vector instance, and the "x" value for the passed instance.
// You'll now multiply them, and push the result onto the evaluation stack.
mthdIL->Emit( OpCodes::Mul_Ovf_Un );
// Now, repeat this for the "y" fields of both vectors.
mthdIL->Emit( OpCodes::Ldarg_0 );
mthdIL->Emit( OpCodes::Ldfld, yField );
mthdIL->Emit( OpCodes::Ldarg_1 );
mthdIL->Emit( OpCodes::Ldfld, yField );
mthdIL->Emit( OpCodes::Mul_Ovf_Un );
// At this time, the results of both multiplications should be atop
// the stack. You'll now add them and push the result onto the stack.
mthdIL->Emit( OpCodes::Add_Ovf_Un );
// Multiply both "z" field and push the result onto the stack.
mthdIL->Emit( OpCodes::Ldarg_0 );
mthdIL->Emit( OpCodes::Ldfld, zField );
mthdIL->Emit( OpCodes::Ldarg_1 );
mthdIL->Emit( OpCodes::Ldfld, zField );
mthdIL->Emit( OpCodes::Mul_Ovf_Un );
// Finally, add the result of multiplying the "z" fields with the
// result of the earlier addition, and push the result - the dot product -
// onto the stack.
mthdIL->Emit( OpCodes::Add_Ovf_Un );
// The "ret" opcode will pop the last value from the stack and return it
// to the calling method. You're all done!
mthdIL->Emit( OpCodes::Ret );
ivType = ivTypeBld->CreateType();
return ivType;
}
int main()
{
Type^ IVType = nullptr;
Object^ aVector1 = nullptr;
Object^ aVector2 = nullptr;
array<Type^>^temp2 = {int::typeid,int::typeid,int::typeid};
array<Type^>^aVtypes = temp2;
array<Object^>^temp3 = {10,10,10};
array<Object^>^aVargs1 = temp3;
array<Object^>^temp4 = {20,20,20};
array<Object^>^aVargs2 = temp4;
// Call the method to build our dynamic class.
IVType = DynamicDotProductGen();
Console::WriteLine( "---" );
ConstructorInfo^ myDTctor = IVType->GetConstructor( aVtypes );
aVector1 = myDTctor->Invoke( aVargs1 );
aVector2 = myDTctor->Invoke( aVargs2 );
array<Object^>^passMe = gcnew array<Object^>(1);
passMe[ 0 ] = dynamic_cast<Object^>(aVector2);
Console::WriteLine( "(10, 10, 10) . (20, 20, 20) = {0}", IVType->InvokeMember( "DotProduct", BindingFlags::InvokeMethod, nullptr, aVector1, passMe ) );
}
// +++ OUTPUT +++
// ---
// (10, 10, 10) . (20, 20, 20) = 600
using System;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;
class TestILGenerator
{
public static Type DynamicDotProductGen()
{
Type ivType = null;
Type[] ctorParams = new Type[] { typeof(int),
typeof(int),
typeof(int)};
AppDomain myDomain = Thread.GetDomain();
AssemblyName myAsmName = new AssemblyName();
myAsmName.Name = "IntVectorAsm";
AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
myAsmName,
AssemblyBuilderAccess.RunAndSave);
ModuleBuilder IntVectorModule = myAsmBuilder.DefineDynamicModule("IntVectorModule",
"Vector.dll");
TypeBuilder ivTypeBld = IntVectorModule.DefineType("IntVector",
TypeAttributes.Public);
FieldBuilder xField = ivTypeBld.DefineField("x", typeof(int),
FieldAttributes.Private);
FieldBuilder yField = ivTypeBld.DefineField("y", typeof(int),
FieldAttributes.Private);
FieldBuilder zField = ivTypeBld.DefineField("z", typeof(int),
FieldAttributes.Private);
Type objType = Type.GetType("System.Object");
ConstructorInfo objCtor = objType.GetConstructor(new Type[0]);
ConstructorBuilder ivCtor = ivTypeBld.DefineConstructor(
MethodAttributes.Public,
CallingConventions.Standard,
ctorParams);
ILGenerator ctorIL = ivCtor.GetILGenerator();
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Call, objCtor);
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Ldarg_1);
ctorIL.Emit(OpCodes.Stfld, xField);
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Ldarg_2);
ctorIL.Emit(OpCodes.Stfld, yField);
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Ldarg_3);
ctorIL.Emit(OpCodes.Stfld, zField);
ctorIL.Emit(OpCodes.Ret);
// This method will find the dot product of the stored vector
// with another.
Type[] dpParams = new Type[] { ivTypeBld };
// Here, you create a MethodBuilder containing the
// name, the attributes (public, static, private, and so on),
// the return type (int, in this case), and a array of Type
// indicating the type of each parameter. Since the sole parameter
// is a IntVector, the very class you're creating, you will
// pass in the TypeBuilder (which is derived from Type) instead of
// a Type object for IntVector, avoiding an exception.
// -- This method would be declared in C# as:
// public int DotProduct(IntVector aVector)
MethodBuilder dotProductMthd = ivTypeBld.DefineMethod(
"DotProduct",
MethodAttributes.Public,
typeof(int),
dpParams);
// A ILGenerator can now be spawned, attached to the MethodBuilder.
ILGenerator mthdIL = dotProductMthd.GetILGenerator();
// Here's the body of our function, in MSIL form. We're going to find the
// "dot product" of the current vector instance with the passed vector
// instance. For reference purposes, the equation is:
// (x1 * x2) + (y1 * y2) + (z1 * z2) = the dot product
// First, you'll load the reference to the current instance "this"
// stored in argument 0 (ldarg.0) onto the stack. Ldfld, the subsequent
// instruction, will pop the reference off the stack and look up the
// field "x", specified by the FieldInfo token "xField".
mthdIL.Emit(OpCodes.Ldarg_0);
mthdIL.Emit(OpCodes.Ldfld, xField);
// That completed, the value stored at field "x" is now atop the stack.
// Now, you'll do the same for the object reference we passed as a
// parameter, stored in argument 1 (ldarg.1). After Ldfld executed,
// you'll have the value stored in field "x" for the passed instance
// atop the stack.
mthdIL.Emit(OpCodes.Ldarg_1);
mthdIL.Emit(OpCodes.Ldfld, xField);
// There will now be two values atop the stack - the "x" value for the
// current vector instance, and the "x" value for the passed instance.
// You'll now multiply them, and push the result onto the evaluation stack.
mthdIL.Emit(OpCodes.Mul_Ovf_Un);
// Now, repeat this for the "y" fields of both vectors.
mthdIL.Emit(OpCodes.Ldarg_0);
mthdIL.Emit(OpCodes.Ldfld, yField);
mthdIL.Emit(OpCodes.Ldarg_1);
mthdIL.Emit(OpCodes.Ldfld, yField);
mthdIL.Emit(OpCodes.Mul_Ovf_Un);
// At this time, the results of both multiplications should be atop
// the stack. You'll now add them and push the result onto the stack.
mthdIL.Emit(OpCodes.Add_Ovf_Un);
// Multiply both "z" field and push the result onto the stack.
mthdIL.Emit(OpCodes.Ldarg_0);
mthdIL.Emit(OpCodes.Ldfld, zField);
mthdIL.Emit(OpCodes.Ldarg_1);
mthdIL.Emit(OpCodes.Ldfld, zField);
mthdIL.Emit(OpCodes.Mul_Ovf_Un);
// Finally, add the result of multiplying the "z" fields with the
// result of the earlier addition, and push the result - the dot product -
// onto the stack.
mthdIL.Emit(OpCodes.Add_Ovf_Un);
// The "ret" opcode will pop the last value from the stack and return it
// to the calling method. You're all done!
mthdIL.Emit(OpCodes.Ret);
ivType = ivTypeBld.CreateType();
return ivType;
}
public static void Main() {
Type IVType = null;
object aVector1 = null;
object aVector2 = null;
Type[] aVtypes = new Type[] {typeof(int), typeof(int), typeof(int)};
object[] aVargs1 = new object[] {10, 10, 10};
object[] aVargs2 = new object[] {20, 20, 20};
// Call the method to build our dynamic class.
IVType = DynamicDotProductGen();
Console.WriteLine("---");
ConstructorInfo myDTctor = IVType.GetConstructor(aVtypes);
aVector1 = myDTctor.Invoke(aVargs1);
aVector2 = myDTctor.Invoke(aVargs2);
object[] passMe = new object[1];
passMe[0] = (object)aVector2;
Console.WriteLine("(10, 10, 10) . (20, 20, 20) = {0}",
IVType.InvokeMember("DotProduct",
BindingFlags.InvokeMethod,
null,
aVector1,
passMe));
// +++ OUTPUT +++
// ---
// (10, 10, 10) . (20, 20, 20) = 600
}
}
Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit
_
Class TestILGenerator
Public Shared Function DynamicDotProductGen() As Type
Dim ivType As Type = Nothing
Dim ctorParams() As Type = {GetType(Integer), GetType(Integer), GetType(Integer)}
Dim myDomain As AppDomain = Thread.GetDomain()
Dim myAsmName As New AssemblyName()
myAsmName.Name = "IntVectorAsm"
Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly( _
myAsmName, _
AssemblyBuilderAccess.RunAndSave)
Dim IntVectorModule As ModuleBuilder = myAsmBuilder.DefineDynamicModule( _
"IntVectorModule", _
"Vector.dll")
Dim ivTypeBld As TypeBuilder = IntVectorModule.DefineType("IntVector", TypeAttributes.Public)
Dim xField As FieldBuilder = ivTypeBld.DefineField("x", _
GetType(Integer), _
FieldAttributes.Private)
Dim yField As FieldBuilder = ivTypeBld.DefineField("y", _
GetType(Integer), _
FieldAttributes.Private)
Dim zField As FieldBuilder = ivTypeBld.DefineField("z", _
GetType(Integer), _
FieldAttributes.Private)
Dim objType As Type = Type.GetType("System.Object")
Dim objCtor As ConstructorInfo = objType.GetConstructor(New Type() {})
Dim ivCtor As ConstructorBuilder = ivTypeBld.DefineConstructor( _
MethodAttributes.Public, _
CallingConventions.Standard, _
ctorParams)
Dim ctorIL As ILGenerator = ivCtor.GetILGenerator()
ctorIL.Emit(OpCodes.Ldarg_0)
ctorIL.Emit(OpCodes.Call, objCtor)
ctorIL.Emit(OpCodes.Ldarg_0)
ctorIL.Emit(OpCodes.Ldarg_1)
ctorIL.Emit(OpCodes.Stfld, xField)
ctorIL.Emit(OpCodes.Ldarg_0)
ctorIL.Emit(OpCodes.Ldarg_2)
ctorIL.Emit(OpCodes.Stfld, yField)
ctorIL.Emit(OpCodes.Ldarg_0)
ctorIL.Emit(OpCodes.Ldarg_3)
ctorIL.Emit(OpCodes.Stfld, zField)
ctorIL.Emit(OpCodes.Ret)
' Now, you'll construct the method find the dot product of two vectors. First,
' let's define the parameters that will be accepted by the method. In this case,
' it's an IntVector itself!
Dim dpParams() As Type = {ivTypeBld}
' Here, you create a MethodBuilder containing the
' name, the attributes (public, static, private, and so on),
' the return type (int, in this case), and a array of Type
' indicating the type of each parameter. Since the sole parameter
' is a IntVector, the very class you're creating, you will
' pass in the TypeBuilder (which is derived from Type) instead of
' a Type object for IntVector, avoiding an exception.
' -- This method would be declared in VB.NET as:
' Public Function DotProduct(IntVector aVector) As Integer
Dim dotProductMthd As MethodBuilder = ivTypeBld.DefineMethod("DotProduct", _
MethodAttributes.Public, GetType(Integer), _
dpParams)
' A ILGenerator can now be spawned, attached to the MethodBuilder.
Dim mthdIL As ILGenerator = dotProductMthd.GetILGenerator()
' Here's the body of our function, in MSIL form. We're going to find the
' "dot product" of the current vector instance with the passed vector
' instance. For reference purposes, the equation is:
' (x1 * x2) + (y1 * y2) + (z1 * z2) = the dot product
' First, you'll load the reference to the current instance "this"
' stored in argument 0 (ldarg.0) onto the stack. Ldfld, the subsequent
' instruction, will pop the reference off the stack and look up the
' field "x", specified by the FieldInfo token "xField".
mthdIL.Emit(OpCodes.Ldarg_0)
mthdIL.Emit(OpCodes.Ldfld, xField)
' That completed, the value stored at field "x" is now atop the stack.
' Now, you'll do the same for the object reference we passed as a
' parameter, stored in argument 1 (ldarg.1). After Ldfld executed,
' you'll have the value stored in field "x" for the passed instance
' atop the stack.
mthdIL.Emit(OpCodes.Ldarg_1)
mthdIL.Emit(OpCodes.Ldfld, xField)
' There will now be two values atop the stack - the "x" value for the
' current vector instance, and the "x" value for the passed instance.
' You'll now multiply them, and push the result onto the evaluation stack.
mthdIL.Emit(OpCodes.Mul_Ovf_Un)
' Now, repeat this for the "y" fields of both vectors.
mthdIL.Emit(OpCodes.Ldarg_0)
mthdIL.Emit(OpCodes.Ldfld, yField)
mthdIL.Emit(OpCodes.Ldarg_1)
mthdIL.Emit(OpCodes.Ldfld, yField)
mthdIL.Emit(OpCodes.Mul_Ovf_Un)
' At this time, the results of both multiplications should be atop
' the stack. You'll now add them and push the result onto the stack.
mthdIL.Emit(OpCodes.Add_Ovf_Un)
' Multiply both "z" field and push the result onto the stack.
mthdIL.Emit(OpCodes.Ldarg_0)
mthdIL.Emit(OpCodes.Ldfld, zField)
mthdIL.Emit(OpCodes.Ldarg_1)
mthdIL.Emit(OpCodes.Ldfld, zField)
mthdIL.Emit(OpCodes.Mul_Ovf_Un)
' Finally, add the result of multiplying the "z" fields with the
' result of the earlier addition, and push the result - the dot product -
' onto the stack.
mthdIL.Emit(OpCodes.Add_Ovf_Un)
' The "ret" opcode will pop the last value from the stack and return it
' to the calling method. You're all done!
mthdIL.Emit(OpCodes.Ret)
ivType = ivTypeBld.CreateType()
Return ivType
End Function 'DynamicDotProductGen
Public Shared Sub Main()
Dim IVType As Type = Nothing
Dim aVector1 As Object = Nothing
Dim aVector2 As Object = Nothing
Dim aVtypes() As Type = {GetType(Integer), GetType(Integer), GetType(Integer)}
Dim aVargs1() As Object = {10, 10, 10}
Dim aVargs2() As Object = {20, 20, 20}
' Call the method to build our dynamic class.
IVType = DynamicDotProductGen()
Dim myDTctor As ConstructorInfo = IVType.GetConstructor(aVtypes)
aVector1 = myDTctor.Invoke(aVargs1)
aVector2 = myDTctor.Invoke(aVargs2)
Console.WriteLine("---")
Dim passMe(0) As Object
passMe(0) = CType(aVector2, Object)
Console.WriteLine("(10, 10, 10) . (20, 20, 20) = {0}", _
IVType.InvokeMember("DotProduct", BindingFlags.InvokeMethod, _
Nothing, aVector1, passMe))
End Sub
End Class
' +++ OUTPUT +++
' ---
' (10, 10, 10) . (20, 20, 20) = 600
Uwagi
Aby uzyskać więcej informacji na temat tego interfejsu API, zobacz dodatkowe uwagi dotyczące interfejsu API dla klasy TypeBuilder.
Konstruktory
TypeBuilder() |
Inicjuje nowe wystąpienie klasy TypeBuilder. |
Pola
UnspecifiedTypeSize |
Reprezentuje ten całkowity rozmiar dla typu nie został określony. |
Właściwości
Assembly |
Pobiera zestaw dynamiczny zawierający tę definicję typu. |
AssemblyQualifiedName |
Zwraca pełną nazwę tego typu kwalifikowaną przez nazwę wyświetlaną zestawu. |
Attributes |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
Attributes |
Pobiera atrybuty skojarzone z elementem Type. (Odziedziczone po Type) |
Attributes |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
BaseType |
Pobiera podstawowy typ tego typu. |
ContainsGenericParameters |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
ContainsGenericParameters |
Pobiera wartość wskazującą, czy bieżący Type obiekt ma parametry typu, które nie zostały zastąpione przez określone typy. (Odziedziczone po Type) |
ContainsGenericParameters |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
CustomAttributes |
Pobiera kolekcję zawierającą atrybuty niestandardowe tego elementu członkowskiego. (Odziedziczone po MemberInfo) |
DeclaredConstructors |
Pobiera kolekcję konstruktorów zadeklarowanych przez bieżący typ. (Odziedziczone po TypeInfo) |
DeclaredEvents |
Pobiera kolekcję zdarzeń zdefiniowanych przez bieżący typ. (Odziedziczone po TypeInfo) |
DeclaredFields |
Pobiera kolekcję pól zdefiniowanych przez bieżący typ. (Odziedziczone po TypeInfo) |
DeclaredMembers |
Pobiera kolekcję elementów członkowskich zdefiniowanych przez bieżący typ. (Odziedziczone po TypeInfo) |
DeclaredMethods |
Pobiera kolekcję metod zdefiniowanych przez bieżący typ. (Odziedziczone po TypeInfo) |
DeclaredNestedTypes |
Pobiera kolekcję zagnieżdżonych typów zdefiniowanych przez bieżący typ. (Odziedziczone po TypeInfo) |
DeclaredProperties |
Pobiera kolekcję właściwości zdefiniowanych przez bieżący typ. (Odziedziczone po TypeInfo) |
DeclaringMethod |
Pobiera metodę, która zadeklarowała bieżący parametr typu ogólnego. |
DeclaringMethod |
Pobiera element MethodBase reprezentujący metodę deklaratora, jeśli bieżący Type reprezentuje parametr typu metody ogólnej. (Odziedziczone po Type) |
DeclaringType |
Zwraca typ, który zadeklarował ten typ. |
FullName |
Pobiera pełną ścieżkę tego typu. |
GenericParameterAttributes |
Pobiera wartość wskazującą kowariancję i specjalne ograniczenia bieżącego parametru typu ogólnego. |
GenericParameterAttributes |
Pobiera kombinację GenericParameterAttributes flag opisujących wariancję i specjalne ograniczenia bieżącego parametru typu ogólnego. (Odziedziczone po Type) |
GenericParameterPosition |
Pobiera pozycję parametru typu na liście parametrów typu typu, który zadeklarował parametr. |
GenericParameterPosition |
Pobiera położenie parametru typu na liście parametrów typu lub metody, która zadeklarowała parametr, gdy Type obiekt reprezentuje parametr typu lub metodę ogólną. (Odziedziczone po Type) |
GenericTypeArguments |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
GenericTypeArguments |
Pobiera tablicę argumentów typu ogólnego dla tego typu. (Odziedziczone po Type) |
GenericTypeArguments |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GenericTypeParameters |
Pobiera tablicę parametrów typu ogólnego bieżącego wystąpienia. (Odziedziczone po TypeInfo) |
GUID |
Pobiera identyfikator GUID tego typu. |
HasElementType |
Pobiera wartość wskazującą, czy bieżący Type obejmuje lub odwołuje się do innego typu; oznacza to, czy bieżący Type jest tablicą, wskaźnikiem, czy jest przekazywany przez odwołanie. (Odziedziczone po Type) |
HasElementType |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
ImplementedInterfaces |
Pobiera kolekcję interfejsów zaimplementowanych przez bieżący typ. (Odziedziczone po TypeInfo) |
IsAbstract |
Pobiera wartość wskazującą, czy Type element jest abstrakcyjny i musi zostać zastąpiony. (Odziedziczone po Type) |
IsAbstract |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsAnsiClass |
Pobiera wartość wskazującą, czy atrybut |
IsAnsiClass |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsArray |
Pobiera wartość wskazującą, czy typ jest tablicą. (Odziedziczone po Type) |
IsArray |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsAutoClass |
Pobiera wartość wskazującą, czy atrybut |
IsAutoClass |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsAutoLayout |
Pobiera wartość wskazującą, czy pola bieżącego typu są tworzone automatycznie przez środowisko uruchomieniowe języka wspólnego. (Odziedziczone po Type) |
IsAutoLayout |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsByRef |
Pobiera wartość wskazującą, czy Type element jest przekazywany przez odwołanie. (Odziedziczone po Type) |
IsByRef |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsByRefLike |
Pobiera wartość wskazującą, czy typ jest strukturą przypominającą byref. |
IsByRefLike |
Pobiera wartość wskazującą, czy typ jest strukturą przypominającą byref. (Odziedziczone po Type) |
IsClass |
Pobiera wartość wskazującą, czy Type jest klasą, czy delegatem, czyli nie typem wartości ani interfejsem. (Odziedziczone po Type) |
IsClass |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsCollectible |
Pobiera wartość wskazującą, czy ten MemberInfo obiekt jest częścią zestawu przechowywanego w kolekcji .AssemblyLoadContext (Odziedziczone po MemberInfo) |
IsCOMObject |
Pobiera wartość wskazującą, czy Type obiekt COM jest obiektem COM. (Odziedziczone po Type) |
IsCOMObject |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsConstructedGenericType |
Pobiera wartość wskazującą, czy ten obiekt reprezentuje skonstruowany typ ogólny. |
IsConstructedGenericType |
Pobiera wartość wskazującą, czy ten obiekt reprezentuje skonstruowany typ ogólny. Możesz utworzyć wystąpienia skonstruowanego typu ogólnego. (Odziedziczone po Type) |
IsContextful |
Pobiera wartość wskazującą, czy Type można je hostować w kontekście. (Odziedziczone po Type) |
IsEnum |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
IsEnum |
Pobiera wartość wskazującą, czy bieżący Type reprezentuje wyliczenie. (Odziedziczone po Type) |
IsEnum |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsExplicitLayout |
Pobiera wartość wskazującą, czy pola bieżącego typu są określone jawnie przesunięć. (Odziedziczone po Type) |
IsExplicitLayout |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsFunctionPointer |
Pobiera wartość wskazującą, czy bieżący Type jest wskaźnikiem funkcji. (Odziedziczone po Type) |
IsGenericMethodParameter |
Pobiera wartość wskazującą, czy bieżący Type reprezentuje parametr typu w definicji metody ogólnej. (Odziedziczone po Type) |
IsGenericParameter |
Pobiera wartość wskazującą, czy bieżący typ jest parametrem typu ogólnego. |
IsGenericParameter |
Pobiera wartość wskazującą, czy bieżący Type reprezentuje parametr typu w definicji typu ogólnego lub metody. (Odziedziczone po Type) |
IsGenericType |
Pobiera wartość wskazującą, czy bieżący typ jest typem ogólnym. |
IsGenericType |
Pobiera wartość wskazującą, czy bieżący typ jest typem ogólnym. (Odziedziczone po Type) |
IsGenericTypeDefinition |
Pobiera wartość wskazującą, czy bieżący TypeBuilder reprezentuje definicję typu ogólnego, z której można konstruować inne typy ogólne. |
IsGenericTypeDefinition |
Pobiera wartość wskazującą, czy bieżący Type reprezentuje definicję typu ogólnego, z której można konstruować inne typy ogólne. (Odziedziczone po Type) |
IsGenericTypeParameter |
Pobiera wartość wskazującą, czy bieżący Type reprezentuje parametr typu w definicji typu ogólnego. (Odziedziczone po Type) |
IsImport |
Pobiera wartość wskazującąComImportAttribute, czy Type zastosowano atrybut wskazujący, że został zaimportowany z biblioteki typów COM. (Odziedziczone po Type) |
IsImport |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsInterface |
Pobiera wartość wskazującą, czy Type element jest interfejsem, czyli nie klasą, czy typem wartości. (Odziedziczone po Type) |
IsInterface |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsLayoutSequential |
Pobiera wartość wskazującą, czy pola bieżącego typu są ułożone sekwencyjnie, w kolejności, w której zostały zdefiniowane lub emitowane do metadanych. (Odziedziczone po Type) |
IsLayoutSequential |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsMarshalByRef |
Pobiera wartość wskazującą, czy element Type jest marshaledowany przez odwołanie. (Odziedziczone po Type) |
IsMarshalByRef |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsNested |
Pobiera wartość wskazującą, czy bieżący Type obiekt reprezentuje typ, którego definicja jest zagnieżdżona wewnątrz definicji innego typu. (Odziedziczone po Type) |
IsNested |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsNestedAssembly |
Pobiera wartość wskazującą, czy Type obiekt jest zagnieżdżony i widoczny tylko w ramach własnego zestawu. (Odziedziczone po Type) |
IsNestedAssembly |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsNestedFamANDAssem |
Pobiera wartość wskazującą, czy Type obiekt jest zagnieżdżony i widoczny tylko dla klas należących zarówno do własnej rodziny, jak i własnego zestawu. (Odziedziczone po Type) |
IsNestedFamANDAssem |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsNestedFamily |
Pobiera wartość wskazującą, czy Type obiekt jest zagnieżdżony i widoczny tylko w obrębie własnej rodziny. (Odziedziczone po Type) |
IsNestedFamily |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsNestedFamORAssem |
Pobiera wartość wskazującą, czy Type obiekt jest zagnieżdżony i widoczny tylko dla klas należących do własnej rodziny, czy do własnego zestawu. (Odziedziczone po Type) |
IsNestedFamORAssem |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsNestedPrivate |
Pobiera wartość wskazującą, czy Type obiekt jest zagnieżdżony i zadeklarowany jako prywatny. (Odziedziczone po Type) |
IsNestedPrivate |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsNestedPublic |
Pobiera wartość wskazującą, czy klasa jest zagnieżdżona i zadeklarowana jako publiczna. (Odziedziczone po Type) |
IsNestedPublic |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsNotPublic |
Pobiera wartość wskazującą Type , czy element nie jest zadeklarowany jako publiczny. (Odziedziczone po Type) |
IsNotPublic |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsPointer |
Pobiera wartość wskazującą, czy Type element jest wskaźnikiem. (Odziedziczone po Type) |
IsPointer |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsPrimitive |
Pobiera wartość wskazującą, czy Type element jest jednym z typów pierwotnych. (Odziedziczone po Type) |
IsPrimitive |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsPublic |
Pobiera wartość wskazującą Type , czy element jest zadeklarowany publicznie. (Odziedziczone po Type) |
IsPublic |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsSealed |
Pobiera wartość wskazującą, czy Type element jest zadeklarowany jako zapieczętowany. (Odziedziczone po Type) |
IsSealed |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsSecurityCritical |
Pobiera wartość wskazującą, czy bieżący typ jest krytyczny dla zabezpieczeń, czy bezpieczny pod względem zabezpieczeń krytyczny, a w związku z tym może wykonywać operacje krytyczne. |
IsSecurityCritical |
Pobiera wartość wskazującą, czy bieżący typ jest krytyczny dla zabezpieczeń, czy krytyczny pod względem zabezpieczeń na bieżącym poziomie zaufania, a zatem może wykonywać operacje krytyczne. (Odziedziczone po Type) |
IsSecuritySafeCritical |
Pobiera wartość wskazującą, czy bieżący typ jest bezpieczny dla bezpieczeństwa krytyczny; oznacza to, czy może wykonywać operacje krytyczne i można uzyskać do niego dostęp za pomocą przezroczystego kodu. |
IsSecuritySafeCritical |
Pobiera wartość wskazującą, czy bieżący typ jest krytyczny pod względem zabezpieczeń na bieżącym poziomie zaufania; oznacza to, czy może wykonywać operacje krytyczne i można uzyskiwać do niego dostęp za pomocą przezroczystego kodu. (Odziedziczone po Type) |
IsSecurityTransparent |
Pobiera wartość wskazującą, czy bieżący typ jest przezroczysty, a zatem nie może wykonywać operacji krytycznych. |
IsSecurityTransparent |
Pobiera wartość wskazującą, czy bieżący typ jest przezroczysty na bieżącym poziomie zaufania i dlatego nie może wykonywać operacji krytycznych. (Odziedziczone po Type) |
IsSerializable |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
IsSerializable |
Przestarzałe.
Pobiera wartość wskazującą Type , czy parametr jest możliwy do serializacji binarnej. (Odziedziczone po Type) |
IsSerializable |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsSignatureType |
Pobiera wartość wskazującą, czy typ jest typem podpisu. (Odziedziczone po Type) |
IsSpecialName |
Pobiera wartość wskazującą, czy typ ma nazwę, która wymaga specjalnej obsługi. (Odziedziczone po Type) |
IsSpecialName |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsSZArray |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
IsSZArray |
Pobiera wartość wskazującą, czy typ jest typem tablicy, który może reprezentować tylko tablicę jednowymiarową z zerową dolną granicą. (Odziedziczone po Type) |
IsTypeDefinition |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
IsTypeDefinition |
Pobiera wartość wskazującą, czy typ jest definicją typu. (Odziedziczone po Type) |
IsUnicodeClass |
Pobiera wartość wskazującą, czy atrybut formatu ciągu jest wybrany dla . |
IsUnicodeClass |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsUnmanagedFunctionPointer |
Pobiera wartość wskazującą, czy bieżący Type jest wskaźnikiem funkcji niezarządzanej. (Odziedziczone po Type) |
IsValueType |
Pobiera wartość wskazującą, czy Type jest typem wartości. (Odziedziczone po Type) |
IsValueType |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsVariableBoundArray |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
IsVariableBoundArray |
Pobiera wartość wskazującą, czy typ jest typem tablicy, który może reprezentować tablicę wielowymiarową, czy tablicę z dowolną dolną granicą. (Odziedziczone po Type) |
IsVisible |
Pobiera wartość wskazującą, czy Type można uzyskać dostęp za pomocą kodu poza zestawem. (Odziedziczone po Type) |
IsVisible |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
MemberType |
Pobiera wartość wskazującą MemberTypes , że ten element członkowski jest typem lub typem zagnieżdżonym. (Odziedziczone po Type) |
MemberType |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
MetadataToken |
Pobiera token identyfikujący bieżący moduł dynamiczny w metadanych. |
MetadataToken |
Pobiera wartość identyfikującą element metadanych. (Odziedziczone po MemberInfo) |
Module |
Pobiera moduł dynamiczny zawierający tę definicję typu. |
Name |
Pobiera nazwę tego typu. |
Namespace |
Pobiera przestrzeń nazw, w której jest ona |
PackingSize |
Pobiera rozmiar pakowania tego typu. |
PackingSizeCore |
Po przesłonięciu w klasie pochodnej pobiera rozmiar pakowania tego typu. |
ReflectedType |
Zwraca typ użyty do uzyskania tego typu. |
ReflectedType |
Pobiera obiekt klasy, który został użyty do uzyskania tego wystąpienia klasy |
Size |
Pobiera całkowity rozmiar typu. |
SizeCore |
Gdy zastąpisz klasę pochodną, pobiera całkowity rozmiar typu. |
StructLayoutAttribute |
Pobiera element StructLayoutAttribute opisujący układ bieżącego typu. (Odziedziczone po Type) |
StructLayoutAttribute |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
TypeHandle |
Nieobsługiwane w modułach dynamicznych. |
TypeInitializer |
Pobiera inicjator dla typu. (Odziedziczone po Type) |
TypeInitializer |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
TypeToken |
Zwraca token typu tego typu. |
UnderlyingSystemType |
Zwraca podstawowy typ systemu dla tego |
UnderlyingSystemType |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
Metody
AddDeclarativeSecurity(SecurityAction, PermissionSet) |
Dodaje zabezpieczenia deklaratywne do tego typu. |
AddInterfaceImplementation(Type) |
Dodaje interfejs implementujący ten typ. |
AddInterfaceImplementationCore(Type) |
Po przesłonięciu w klasie pochodnej dodaje interfejs implementujący ten typ. |
AsType() |
Zwraca bieżący typ jako Type obiekt. (Odziedziczone po TypeInfo) |
CreateType() |
Type Tworzy obiekt dla klasy . Po zdefiniowaniu pól i metod w klasie jest wywoływana w |
CreateTypeInfo() |
TypeInfo Pobiera obiekt reprezentujący ten typ. |
CreateTypeInfoCore() |
Po przesłonięciu w klasie pochodnej pobiera TypeInfo obiekt reprezentujący ten typ. |
DefineConstructor(MethodAttributes, CallingConventions, Type[]) |
Dodaje nowy konstruktor do typu z podanymi atrybutami i podpisem. |
DefineConstructor(MethodAttributes, CallingConventions, Type[], Type[][], Type[][]) |
Dodaje nowy konstruktor do typu z podanymi atrybutami, podpisem i modyfikatorami niestandardowymi. |
DefineConstructorCore(MethodAttributes, CallingConventions, Type[], Type[][], Type[][]) |
Po zastąpieniu w klasie pochodnej dodaje nowy konstruktor do typu z podanymi atrybutami, podpisem i modyfikatorami niestandardowymi. |
DefineDefaultConstructor(MethodAttributes) |
Definiuje konstruktor bez parametrów. Konstruktor zdefiniowany w tym miejscu po prostu wywoła konstruktor bez parametrów obiektu nadrzędnego. |
DefineDefaultConstructorCore(MethodAttributes) |
Podczas zastępowania w klasie pochodnej definiuje konstruktor bez parametrów. Konstruktor zdefiniowany tutaj wywołuje konstruktor bez parametrów obiektu nadrzędnego. |
DefineEvent(String, EventAttributes, Type) |
Dodaje nowe zdarzenie do typu z daną nazwą, atrybutami i typem zdarzenia. |
DefineEventCore(String, EventAttributes, Type) |
Po zastąpieniu w klasie pochodnej dodaje nowe zdarzenie do typu z daną nazwą, atrybutami i typem zdarzenia. |
DefineField(String, Type, FieldAttributes) |
Dodaje nowe pole do typu z daną nazwą, atrybutami i typem pola. |
DefineField(String, Type, Type[], Type[], FieldAttributes) |
Dodaje nowe pole do typu z daną nazwą, atrybutami, typem pola i modyfikatorami niestandardowymi. |
DefineFieldCore(String, Type, Type[], Type[], FieldAttributes) |
Po zastąpieniu w klasie pochodnej dodaje nowe pole do typu z daną nazwą, atrybutami, typem pola i modyfikatorami niestandardowymi. |
DefineGenericParameters(String[]) |
Definiuje ogólne parametry typu dla bieżącego typu, określając ich liczbę i nazwy, oraz zwraca tablicę GenericTypeParameterBuilder obiektów, których można użyć do ustawienia ich ograniczeń. |
DefineGenericParametersCore(String[]) |
Podczas zastępowania w klasie pochodnej definiuje parametry typu ogólnego dla bieżącego typu, określając ich liczbę i nazwy. |
DefineInitializedData(String, Byte[], FieldAttributes) |
Definiuje zainicjowane pole danych w sekcji sdata przenośnego pliku wykonywalnego (PE). |
DefineInitializedDataCore(String, Byte[], FieldAttributes) |
Po zastąpieniu w klasie pochodnej definiuje zainicjowane pole danych w sekcji sdata przenośnego pliku wykonywalnego (PE). |
DefineMethod(String, MethodAttributes) |
Dodaje nową metodę do typu z określonymi atrybutami nazwy i metody. |
DefineMethod(String, MethodAttributes, CallingConventions) |
Dodaje nową metodę do typu z określoną nazwą, atrybutami metody i konwencją wywoływania. |
DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[]) |
Dodaje nową metodę do typu z określoną nazwą, atrybutami metody, konwencją wywoływania i podpisem metody. |
DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][]) |
Dodaje nową metodę do typu z określoną nazwą, atrybutami metody, konwencją wywoływania, sygnaturą metody i modyfikatorami niestandardowymi. |
DefineMethod(String, MethodAttributes, Type, Type[]) |
Dodaje nową metodę do typu z określoną nazwą, atrybutami metody i sygnaturą metody. |
DefineMethodCore(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][]) |
Po zastąpieniu w klasie pochodnej dodaje nową metodę do typu z określoną nazwą, atrybutami metody, konwencją wywoływania, sygnaturą metody i modyfikatorami niestandardowymi. |
DefineMethodOverride(MethodInfo, MethodInfo) |
Określa daną treść metody, która implementuje daną deklarację metody, potencjalnie o innej nazwie. |
DefineMethodOverrideCore(MethodInfo, MethodInfo) |
Podczas zastępowania w klasie pochodnej określa daną treść metody, która implementuje daną deklarację metody, potencjalnie o innej nazwie. |
DefineNestedType(String) |
Definiuje typ zagnieżdżony, biorąc pod uwagę jego nazwę. |
DefineNestedType(String, TypeAttributes) |
Definiuje typ zagnieżdżony, biorąc pod uwagę jego nazwę i atrybuty. |
DefineNestedType(String, TypeAttributes, Type) |
Definiuje typ zagnieżdżony, biorąc pod uwagę jego nazwę, atrybuty i typ, który rozszerza. |
DefineNestedType(String, TypeAttributes, Type, Int32) |
Definiuje typ zagnieżdżony, biorąc pod uwagę jego nazwę, atrybuty, całkowity rozmiar typu i typ, który rozszerza. |
DefineNestedType(String, TypeAttributes, Type, PackingSize) |
Definiuje typ zagnieżdżony, biorąc pod uwagę jego nazwę, atrybuty, typ, który rozszerza i rozmiar pakowania. |
DefineNestedType(String, TypeAttributes, Type, PackingSize, Int32) |
Definiuje typ zagnieżdżony, biorąc pod uwagę jego nazwę, atrybuty, rozmiar i typ, który rozszerza. |
DefineNestedType(String, TypeAttributes, Type, Type[]) |
Definiuje typ zagnieżdżony, biorąc pod uwagę jego nazwę, atrybuty, typ, który rozszerza, oraz interfejsy, które implementuje. |
DefineNestedTypeCore(String, TypeAttributes, Type, Type[], PackingSize, Int32) |
Po zastąpieniu w klasie pochodnej definiuje typ zagnieżdżony, biorąc pod uwagę jego nazwę, atrybuty, rozmiar i typ, który rozszerza. |
DefinePInvokeMethod(String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet) |
Definiuje metodę |
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet) |
Definiuje metodę nadaną |
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][], CallingConvention, CharSet) |
Definiuje metodę nadaną |
DefinePInvokeMethodCore(String, String, String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][], CallingConvention, CharSet) |
Po zastąpieniu w klasie pochodnej definiuje metodę PInvoke z podaną nazwą, nazwą biblioteki DLL, nazwą punktu wejścia, atrybutami, konwencją wywoływania, typem zwracanym, typami parametrów, flagami PInvoke i modyfikatorami niestandardowymi parametrów i zwracanym typem. |
DefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[]) |
Dodaje nową właściwość do typu z daną nazwą, atrybutami, konwencją wywoływania i podpisem właściwości. |
DefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][]) |
Dodaje nową właściwość do typu z daną nazwą, wywoływaniem konwencji, sygnaturą właściwości i modyfikatorami niestandardowymi. |
DefineProperty(String, PropertyAttributes, Type, Type[]) |
Dodaje nową właściwość do typu z podaną nazwą i podpisem właściwości. |
DefineProperty(String, PropertyAttributes, Type, Type[], Type[], Type[], Type[][], Type[][]) |
Dodaje nową właściwość do typu z daną nazwą, podpisem właściwości i modyfikatorami niestandardowymi. |
DefinePropertyCore(String, PropertyAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][]) |
Po zastąpieniu w klasie pochodnej dodaje nową właściwość do typu z daną nazwą, konwencją wywoływania, sygnaturą właściwości i modyfikatorami niestandardowymi. |
DefineTypeInitializer() |
Definiuje inicjator dla tego typu. |
DefineTypeInitializerCore() |
Podczas zastępowania w klasie pochodnej definiuje inicjator dla tego typu. |
DefineUninitializedData(String, Int32, FieldAttributes) |
Definiuje niezainicjowane pole danych w |
DefineUninitializedDataCore(String, Int32, FieldAttributes) |
Po zastąpieniu w klasie pochodnej definiuje niezainicjowane pole danych w |
Equals(Object) |
Określa, czy bazowy typ systemu bieżącego Type obiektu jest taki sam jak podstawowy typ systemu określonego Object. (Odziedziczone po Type) |
Equals(Object) |
Zwraca wartość wskazującą, czy to wystąpienie jest równe podanemu obiektowi. (Odziedziczone po MemberInfo) |
Equals(Type) |
Określa, czy podstawowy typ systemu bieżącego Type jest taki sam jak podstawowy typ systemu określonego Type. (Odziedziczone po Type) |
FindInterfaces(TypeFilter, Object) |
Zwraca tablicę Type obiektów reprezentujących filtrowaną listę interfejsów implementowanych lub dziedziczone przez bieżący Typeelement . (Odziedziczone po Type) |
FindInterfaces(TypeFilter, Object) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object) |
Zwraca filtrowaną tablicę MemberInfo obiektów określonego typu elementu członkowskiego. (Odziedziczone po Type) |
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetArrayRank() |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
GetArrayRank() |
Pobiera liczbę wymiarów w tablicy. (Odziedziczone po Type) |
GetArrayRank() |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetAttributeFlagsImpl() |
Po zastąpieniu w klasie pochodnej implementuje Attributes właściwość i pobiera bitową kombinację wartości wyliczenia, które wskazują atrybuty skojarzone z Type. |
GetAttributeFlagsImpl() |
W przypadku zastąpienia w klasie pochodnej implementuje Attributes właściwość i pobiera bitową kombinację wartości wyliczenia, które wskazują atrybuty skojarzone z parametrem Type. (Odziedziczone po Type) |
GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[]) |
Wyszukuje konstruktor, którego parametry są zgodne z określonymi typami argumentów i modyfikatorami, przy użyciu określonych ograniczeń powiązania i określonej konwencji wywoływania. (Odziedziczone po Type) |
GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[]) |
Wyszukuje konstruktor, którego parametry są zgodne z określonymi typami argumentów i modyfikatorami przy użyciu określonych ograniczeń powiązania. (Odziedziczone po Type) |
GetConstructor(BindingFlags, Type[]) |
Wyszukuje konstruktor, którego parametry są zgodne z określonymi typami argumentów, przy użyciu określonych ograniczeń powiązania. (Odziedziczone po Type) |
GetConstructor(Type, ConstructorInfo) |
Zwraca konstruktor określonego skonstruowanego typu ogólnego, który odpowiada określonemu konstruktorowi definicji typu ogólnego. |
GetConstructor(Type[]) |
Wyszukuje konstruktor wystąpienia publicznego, którego parametry są zgodne z typami w określonej tablicy. (Odziedziczone po Type) |
GetConstructor(Type[]) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[]) |
Podczas zastępowania w klasie pochodnej wyszukuje konstruktora, którego parametry są zgodne z określonymi typami argumentów i modyfikatorami, przy użyciu określonych ograniczeń powiązania i określonej konwencji wywoływania. |
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[]) |
W przypadku zastąpienia w klasie pochodnej wyszukuje konstruktor, którego parametry są zgodne z określonymi typami argumentów i modyfikatorami, przy użyciu określonych ograniczeń powiązania i określonej konwencji wywoływania. (Odziedziczone po Type) |
GetConstructors() |
Zwraca wszystkie konstruktory publiczne zdefiniowane dla bieżącego Typeelementu . (Odziedziczone po Type) |
GetConstructors() |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetConstructors(BindingFlags) |
Zwraca tablicę ConstructorInfo obiektów reprezentujących konstruktory publiczne i inne niż publiczne zdefiniowane dla tej klasy zgodnie z definicją. |
GetConstructors(BindingFlags) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetCustomAttributes(Boolean) |
Zwraca wszystkie atrybuty niestandardowe zdefiniowane dla tego typu. |
GetCustomAttributes(Boolean) |
Po zastąpieniu klasy pochodnej zwraca tablicę wszystkich atrybutów niestandardowych zastosowanych do tego elementu członkowskiego. (Odziedziczone po MemberInfo) |
GetCustomAttributes(Type, Boolean) |
Zwraca wszystkie atrybuty niestandardowe bieżącego typu, które można przypisać do określonego typu. |
GetCustomAttributes(Type, Boolean) |
Po przesłonięciu w klasie pochodnej zwraca tablicę atrybutów niestandardowych zastosowanych do tego elementu członkowskiego i zidentyfikowaną przez Typemetodę . (Odziedziczone po MemberInfo) |
GetCustomAttributesData() |
Zwraca listę CustomAttributeData obiektów reprezentujących dane dotyczące atrybutów, które zostały zastosowane do elementu członkowskiego docelowego. (Odziedziczone po MemberInfo) |
GetDeclaredEvent(String) |
Zwraca obiekt reprezentujący określone zdarzenie zadeklarowane przez bieżący typ. (Odziedziczone po TypeInfo) |
GetDeclaredField(String) |
Zwraca obiekt reprezentujący określone pole zadeklarowane przez bieżący typ. (Odziedziczone po TypeInfo) |
GetDeclaredMethod(String) |
Zwraca obiekt reprezentujący określoną metodę zadeklarowaną przez bieżący typ. (Odziedziczone po TypeInfo) |
GetDeclaredMethods(String) |
Zwraca kolekcję zawierającą wszystkie metody zadeklarowane w bieżącym typie zgodnym z określoną nazwą. (Odziedziczone po TypeInfo) |
GetDeclaredNestedType(String) |
Zwraca obiekt reprezentujący określony typ zagnieżdżony zadeklarowany przez bieżący typ. (Odziedziczone po TypeInfo) |
GetDeclaredProperty(String) |
Zwraca obiekt reprezentujący określoną właściwość zadeklarowaną przez bieżący typ. (Odziedziczone po TypeInfo) |
GetDefaultMembers() |
Wyszukuje elementy członkowskie zdefiniowane dla bieżącego Type zestawu DefaultMemberAttribute . (Odziedziczone po Type) |
GetDefaultMembers() |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetElementType() |
Wywołanie tej metody zawsze zgłasza wyjątek NotSupportedException. |
GetEnumName(Object) |
Zwraca nazwę stałej, która ma określoną wartość dla bieżącego typu wyliczenia. (Odziedziczone po Type) |
GetEnumName(Object) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetEnumNames() |
Zwraca nazwy elementów członkowskich bieżącego typu wyliczenia. (Odziedziczone po Type) |
GetEnumNames() |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetEnumUnderlyingType() |
Zwraca typ bazowy bieżącego typu wyliczenia. (Odziedziczone po Type) |
GetEnumUnderlyingType() |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetEnumValues() |
Zwraca tablicę wartości stałych w bieżącym typie wyliczania. (Odziedziczone po Type) |
GetEnumValues() |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetEnumValuesAsUnderlyingType() |
Pobiera tablicę wartości stałych typu bazowego tego typu wyliczenia. (Odziedziczone po Type) |
GetEvent(String) |
EventInfo Zwraca obiekt reprezentujący określone zdarzenie publiczne. (Odziedziczone po Type) |
GetEvent(String) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetEvent(String, BindingFlags) |
Zwraca zdarzenie o określonej nazwie. |
GetEvent(String, BindingFlags) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetEvents() |
Zwraca zdarzenia publiczne zadeklarowane lub dziedziczone przez ten typ. |
GetEvents() |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetEvents(BindingFlags) |
Zwraca zdarzenia publiczne i inne niż publiczne zadeklarowane przez ten typ. |
GetEvents(BindingFlags) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetField(String) |
Wyszukuje pole publiczne o określonej nazwie. (Odziedziczone po Type) |
GetField(String) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetField(String, BindingFlags) |
Zwraca pole określone przez daną nazwę. |
GetField(String, BindingFlags) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetField(Type, FieldInfo) |
Zwraca pole określonego skonstruowanego typu ogólnego, które odpowiada określonemu polu definicji typu ogólnego. |
GetFields() |
Zwraca wszystkie pola publiczne bieżącego Typeelementu . (Odziedziczone po Type) |
GetFields() |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetFields(BindingFlags) |
Zwraca pola publiczne i inne niż publiczne zadeklarowane przez ten typ. |
GetFields(BindingFlags) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetFunctionPointerCallingConventions() |
W przypadku zastąpienia w klasie pochodnej zwraca konwencje wywoływania bieżącego wskaźnika Typefunkcji . (Odziedziczone po Type) |
GetFunctionPointerParameterTypes() |
Po zastąpieniu w klasie pochodnej zwraca typy parametrów bieżącego wskaźnika Typefunkcji . (Odziedziczone po Type) |
GetFunctionPointerReturnType() |
Gdy zastąpisz klasę pochodną, zwraca typ zwracany przez bieżący wskaźnik Typefunkcji . (Odziedziczone po Type) |
GetGenericArguments() |
Zwraca tablicę Type obiektów reprezentujących argumenty typu typu ogólnego lub parametry typu definicji typu ogólnego. |
GetGenericArguments() |
Zwraca tablicę Type obiektów reprezentujących argumenty typu zamkniętego typu ogólnego lub parametry typu definicji typu ogólnego. (Odziedziczone po Type) |
GetGenericArguments() |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetGenericParameterConstraints() |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
GetGenericParameterConstraints() |
Zwraca tablicę Type obiektów reprezentujących ograniczenia bieżącego parametru typu ogólnego. (Odziedziczone po Type) |
GetGenericParameterConstraints() |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetGenericTypeDefinition() |
Zwraca obiekt reprezentujący definicję Type typu ogólnego, z której można uzyskać bieżący typ. |
GetGenericTypeDefinition() |
Type Zwraca obiekt reprezentujący ogólną definicję typu, z której można konstruować bieżący typ ogólny. (Odziedziczone po Type) |
GetHashCode() |
Zwraca wartość skrótu dla tego wystąpienia. (Odziedziczone po Type) |
GetHashCode() |
Zwraca wartość skrótu dla tego wystąpienia. (Odziedziczone po MemberInfo) |
GetInterface(String) |
Wyszukuje interfejs o określonej nazwie. (Odziedziczone po Type) |
GetInterface(String) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetInterface(String, Boolean) |
Zwraca interfejs zaimplementowany (bezpośrednio lub pośrednio) przez tę klasę z w pełni kwalifikowaną nazwą zgodną z daną nazwą interfejsu. |
GetInterface(String, Boolean) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetInterfaceMap(Type) |
Zwraca mapowanie interfejsu dla żądanego interfejsu. |
GetInterfaces() |
Zwraca tablicę wszystkich interfejsów zaimplementowanych na tym typie i jego typach podstawowych. |
GetInterfaces() |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetMember(String) |
Wyszukuje publicznych członków o określonej nazwie. (Odziedziczone po Type) |
GetMember(String) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetMember(String, BindingFlags) |
Wyszukuje określone elementy członkowskie przy użyciu określonych ograniczeń powiązania. (Odziedziczone po Type) |
GetMember(String, BindingFlags) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetMember(String, MemberTypes, BindingFlags) |
Zwraca wszystkie publiczne i niepubliczone elementy członkowskie zadeklarowane lub dziedziczone przez ten typ zgodnie z określonym typem. |
GetMember(String, MemberTypes, BindingFlags) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetMembers() |
Zwraca wszystkich publicznych członków bieżącego Typeobiektu . (Odziedziczone po Type) |
GetMembers() |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetMembers(BindingFlags) |
Zwraca elementy członkowskie dla publicznych i innych niż publiczne elementy członkowskie zadeklarowane lub dziedziczone przez ten typ. |
GetMembers(BindingFlags) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetMemberWithSameMetadataDefinitionAs(MemberInfo) |
Wyszukuje element MemberInfo w bieżącym Type , który pasuje do określonego MemberInfoelementu . (Odziedziczone po Type) |
GetMethod(String) |
Wyszukuje metodę publiczną o określonej nazwie. (Odziedziczone po Type) |
GetMethod(String) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetMethod(String, BindingFlags) |
Wyszukuje określoną metodę przy użyciu określonych ograniczeń powiązania. (Odziedziczone po Type) |
GetMethod(String, BindingFlags) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[]) |
Wyszukuje określoną metodę, której parametry są zgodne z określonymi typami argumentów i modyfikatorami, przy użyciu określonych ograniczeń powiązania i określonej konwencji wywoływania. (Odziedziczone po Type) |
GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[]) |
Wyszukuje określoną metodę, której parametry są zgodne z określonymi typami argumentów i modyfikatorami przy użyciu określonych ograniczeń powiązania. (Odziedziczone po Type) |
GetMethod(String, BindingFlags, Type[]) |
Wyszukuje określoną metodę, której parametry są zgodne z określonymi typami argumentów, przy użyciu określonych ograniczeń powiązania. (Odziedziczone po Type) |
GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[]) |
Wyszukuje określoną metodę, której parametry są zgodne z określoną ogólną liczbą parametrów, typami argumentów i modyfikatorami, przy użyciu określonych ograniczeń powiązania i określonej konwencji wywoływania. (Odziedziczone po Type) |
GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[]) |
Wyszukuje określoną metodę, której parametry są zgodne z określoną ogólną liczbą parametrów, typami argumentów i modyfikatorami przy użyciu określonych ograniczeń powiązania. (Odziedziczone po Type) |
GetMethod(String, Int32, BindingFlags, Type[]) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po Type) |
GetMethod(String, Int32, Type[]) |
Wyszukuje określoną metodę publiczną, której parametry są zgodne z określoną ogólną liczbą parametrów i typami argumentów. (Odziedziczone po Type) |
GetMethod(String, Int32, Type[], ParameterModifier[]) |
Wyszukuje określoną metodę publiczną, której parametry są zgodne z określoną ogólną liczbą parametrów, typami argumentów i modyfikatorami. (Odziedziczone po Type) |
GetMethod(String, Type[]) |
Wyszukuje określoną metodę publiczną, której parametry są zgodne z określonymi typami argumentów. (Odziedziczone po Type) |
GetMethod(String, Type[]) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetMethod(String, Type[], ParameterModifier[]) |
Wyszukuje określoną metodę publiczną, której parametry są zgodne z określonymi typami argumentów i modyfikatorami. (Odziedziczone po Type) |
GetMethod(String, Type[], ParameterModifier[]) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetMethod(Type, MethodInfo) |
Zwraca metodę określonego skonstruowanego typu ogólnego, który odpowiada określonej metodzie definicji typu ogólnego. |
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[]) |
W przypadku zastąpienia w klasie pochodnej wyszukuje określoną metodę, której parametry są zgodne z określonymi typami argumentów i modyfikatorami, przy użyciu określonych ograniczeń powiązania i określonej konwencji wywoływania. |
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[]) |
W przypadku zastąpienia w klasie pochodnej wyszukuje określoną metodę, której parametry są zgodne z określonymi typami argumentów i modyfikatorami, przy użyciu określonych ograniczeń powiązania i określonej konwencji wywoływania. (Odziedziczone po Type) |
GetMethodImpl(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[]) |
W przypadku zastąpienia w klasie pochodnej wyszukuje określoną metodę, której parametry są zgodne z określoną ogólną liczbą parametrów, typami argumentów i modyfikatorami, przy użyciu określonych ograniczeń powiązania i określonej konwencji wywoływania. (Odziedziczone po Type) |
GetMethods() |
Zwraca wszystkie publiczne metody bieżącego Typeobiektu . (Odziedziczone po Type) |
GetMethods() |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetMethods(BindingFlags) |
Zwraca wszystkie metody publiczne i inne niż publiczne zadeklarowane lub dziedziczone przez ten typ zgodnie z definicją. |
GetMethods(BindingFlags) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetNestedType(String) |
Wyszukuje zagnieżdżony typ publiczny o określonej nazwie. (Odziedziczone po Type) |
GetNestedType(String) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetNestedType(String, BindingFlags) |
Zwraca typy zagnieżdżone publicznie i inne niż publiczne zadeklarowane przez ten typ. |
GetNestedType(String, BindingFlags) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetNestedTypes() |
Zwraca typy publiczne zagnieżdżone w bieżącym obiekcie Type. (Odziedziczone po Type) |
GetNestedTypes() |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetNestedTypes(BindingFlags) |
Zwraca typy zagnieżdżone publicznie i niepubliczone, które są deklarowane lub dziedziczone przez ten typ. |
GetNestedTypes(BindingFlags) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetOptionalCustomModifiers() |
Po przesłonięciu w klasie pochodnej zwraca opcjonalne modyfikatory niestandardowe bieżącego Typeelementu . (Odziedziczone po Type) |
GetProperties() |
Zwraca wszystkie właściwości publiczne bieżącego Typeelementu . (Odziedziczone po Type) |
GetProperties() |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetProperties(BindingFlags) |
Zwraca wszystkie właściwości publiczne i inne niż publiczne zadeklarowane lub dziedziczone przez ten typ, zgodnie z definicją. |
GetProperties(BindingFlags) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetProperty(String) |
Wyszukuje właściwość publiczną o określonej nazwie. (Odziedziczone po Type) |
GetProperty(String) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetProperty(String, BindingFlags) |
Wyszukuje określoną właściwość przy użyciu określonych ograniczeń powiązania. (Odziedziczone po Type) |
GetProperty(String, BindingFlags) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[]) |
Wyszukuje określoną właściwość, której parametry są zgodne z określonymi typami argumentów i modyfikatorami, używając określonych ograniczeń powiązania. (Odziedziczone po Type) |
GetProperty(String, Type) |
Wyszukuje właściwość publiczną o określonej nazwie i typie zwracania. (Odziedziczone po Type) |
GetProperty(String, Type) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetProperty(String, Type, Type[]) |
Wyszukuje określoną właściwość publiczną, której parametry są zgodne z określonymi typami argumentów. (Odziedziczone po Type) |
GetProperty(String, Type, Type[]) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetProperty(String, Type, Type[], ParameterModifier[]) |
Wyszukuje określoną właściwość publiczną, której parametry są zgodne z określonymi typami argumentów i modyfikatorami. (Odziedziczone po Type) |
GetProperty(String, Type, Type[], ParameterModifier[]) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetProperty(String, Type[]) |
Wyszukuje określoną właściwość publiczną, której parametry są zgodne z określonymi typami argumentów. (Odziedziczone po Type) |
GetProperty(String, Type[]) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[]) |
W przypadku zastąpienia w klasie pochodnej wyszukuje określoną właściwość, której parametry są zgodne z określonymi typami argumentów i modyfikatorami przy użyciu określonych ograniczeń powiązania. |
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[]) |
W przypadku zastąpienia w klasie pochodnej wyszukuje określoną właściwość, której parametry są zgodne z określonymi typami argumentów i modyfikatorami przy użyciu określonych ograniczeń powiązania. (Odziedziczone po Type) |
GetRequiredCustomModifiers() |
Po przesłonięciu w klasie pochodnej zwraca wymagane niestandardowe modyfikatory bieżącego Typeelementu . (Odziedziczone po Type) |
GetType() |
Pobiera bieżący element Type. (Odziedziczone po Type) |
GetType() |
Odnajduje atrybuty elementu członkowskiego i zapewnia dostęp do metadanych składowych. (Odziedziczone po MemberInfo) |
GetTypeCodeImpl() |
Zwraca podstawowy kod typu tego Type wystąpienia. (Odziedziczone po Type) |
HasElementTypeImpl() |
W przypadku zastąpienia w klasie pochodnej implementuje HasElementType właściwość i określa, czy bieżący obejmuje lub odwołuje się do innego typu; oznacza to, czy bieżący TypeType jest tablicą, wskaźnikiem, czy jest przekazywany przez odwołanie. |
HasElementTypeImpl() |
W przypadku zastąpienia w klasie pochodnej implementuje HasElementType właściwość i określa, czy bieżący obejmuje lub odwołuje się do innego typu; oznacza to, czy bieżący TypeType jest tablicą, wskaźnikiem, czy jest przekazywany przez odwołanie. (Odziedziczone po Type) |
HasSameMetadataDefinitionAs(MemberInfo) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po MemberInfo) |
InvokeMember(String, BindingFlags, Binder, Object, Object[]) |
Wywołuje określony element członkowski przy użyciu określonych ograniczeń powiązania i dopasowywania określonej listy argumentów. (Odziedziczone po Type) |
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo) |
Wywołuje określony element członkowski przy użyciu określonych ograniczeń powiązania i dopasowywania określonej listy argumentów i kultury. (Odziedziczone po Type) |
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]) |
Wywołuje określony element członkowski. Wywoływana metoda musi być dostępna i zapewnić najbardziej specyficzne dopasowanie z określoną listą argumentów w ramach ograniczeń określonych atrybutów powiązania i wywołania. |
IsArrayImpl() |
W przypadku zastąpienia w klasie pochodnej implementuje IsArray właściwość i określa, czy Type jest tablicą. |
IsArrayImpl() |
W przypadku zastąpienia w klasie pochodnej implementuje IsArray właściwość i określa, czy Type jest tablicą. (Odziedziczone po Type) |
IsAssignableFrom(Type) |
Pobiera wartość wskazującą, czy określony Type można przypisać do tego obiektu. |
IsAssignableFrom(Type) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsAssignableFrom(TypeInfo) |
Pobiera wartość wskazującą, czy TypeInfo określony obiekt można przypisać do tego obiektu. |
IsAssignableTo(Type) |
Określa, czy bieżący typ można przypisać do zmiennej określonego |
IsByRefImpl() |
Po przesłonięciu w klasie pochodnej implementuje IsByRef właściwość i określa, czy Type element jest przekazywany przez odwołanie. |
IsByRefImpl() |
Po przesłonięciu w klasie pochodnej implementuje IsByRef właściwość i określa, czy Type element jest przekazywany przez odwołanie. (Odziedziczone po Type) |
IsCOMObjectImpl() |
W przypadku zastąpienia w klasie pochodnej implementuje IsCOMObject właściwość i określa, czy Type obiekt COM jest obiektem COM. |
IsCOMObjectImpl() |
W przypadku zastąpienia w klasie pochodnej implementuje IsCOMObject właściwość i określa, czy Type obiekt COM jest obiektem COM. (Odziedziczone po Type) |
IsContextfulImpl() |
Implementuje IsContextful właściwość i określa, czy Type można go hostować w kontekście. (Odziedziczone po Type) |
IsCreated() |
Zwraca wartość wskazującą, czy został utworzony bieżący typ dynamiczny. |
IsCreatedCore() |
Po zastąpieniu klasy pochodnej zwraca wartość wskazującą, czy został utworzony bieżący typ dynamiczny. |
IsDefined(Type, Boolean) |
Określa, czy atrybut niestandardowy jest stosowany do bieżącego typu. |
IsDefined(Type, Boolean) |
W przypadku zastąpienia w klasie pochodnej wskazuje, czy do tego elementu członkowskiego zastosowano co najmniej jeden atrybut określonego typu, czy jego typów pochodnych. (Odziedziczone po MemberInfo) |
IsEnumDefined(Object) |
Zwraca wartość wskazującą, czy określona wartość istnieje w bieżącym typie wyliczenia. (Odziedziczone po Type) |
IsEnumDefined(Object) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsEquivalentTo(Type) |
Określa, czy dwa typy MODELU COM mają tę samą tożsamość i kwalifikują się do równoważności typów. (Odziedziczone po Type) |
IsEquivalentTo(Type) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsInstanceOfType(Object) |
Określa, czy określony obiekt jest wystąpieniem bieżącego Typeobiektu . (Odziedziczone po Type) |
IsInstanceOfType(Object) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsMarshalByRefImpl() |
Implementuje IsMarshalByRef właściwość i określa, czy obiekt Type jest marshaledowany przez odwołanie. (Odziedziczone po Type) |
IsPointerImpl() |
W przypadku zastąpienia w klasie pochodnej implementuje IsPointer właściwość i określa, czy Type jest wskaźnikiem. |
IsPointerImpl() |
Podczas zastępowania w klasie pochodnej implementuje IsPointer właściwość i określa, czy Type element jest wskaźnikiem. (Odziedziczone po Type) |
IsPrimitiveImpl() |
W przypadku zastąpienia w klasie pochodnej implementuje IsPrimitive właściwość i określa, czy Type jest to jeden z typów pierwotnych. |
IsPrimitiveImpl() |
Podczas zastępowania w klasie pochodnej implementuje IsPrimitive właściwość i określa, czy Type jest to jeden z typów pierwotnych. (Odziedziczone po Type) |
IsSubclassOf(Type) |
Określa, czy ten typ pochodzi z określonego typu. |
IsSubclassOf(Type) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. (Odziedziczone po TypeInfo) |
IsValueTypeImpl() |
Implementuje IsValueType właściwość i określa, czy Type jest to typ wartości, czyli, a nie klasa lub interfejs. (Odziedziczone po Type) |
MakeArrayType() |
Zwraca obiekt reprezentujący tablicę Type jednowymiarową bieżącego typu z dolną granicą zera. |
MakeArrayType() |
Type Zwraca obiekt reprezentujący jednowymiarową tablicę bieżącego typu z dolną granicą zera. (Odziedziczone po Type) |
MakeArrayType(Int32) |
Zwraca obiekt reprezentujący tablicę Type bieżącego typu z określoną liczbą wymiarów. |
MakeArrayType(Int32) |
Type Zwraca obiekt reprezentujący tablicę bieżącego typu z określoną liczbą wymiarów. (Odziedziczone po Type) |
MakeByRefType() |
Type Zwraca obiekt, który reprezentuje bieżący typ po przekazaniu jako |
MakeByRefType() |
Type Zwraca obiekt, który reprezentuje bieżący typ po przekazaniu jako |
MakeGenericType(Type[]) |
Zastępuje elementy tablicy typów dla parametrów typu bieżącej definicji typu ogólnego i zwraca wynikowy typ skonstruowany. |
MakeGenericType(Type[]) |
Podstawia elementy tablicy typów dla parametrów typu bieżącej definicji typu ogólnego i zwraca Type obiekt reprezentujący wynikowy typ skonstruowany. (Odziedziczone po Type) |
MakePointerType() |
Type Zwraca obiekt reprezentujący typ wskaźnika niezarządzanego do bieżącego typu. |
MakePointerType() |
Type Zwraca obiekt reprezentujący wskaźnik do bieżącego typu. (Odziedziczone po Type) |
MemberwiseClone() |
Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object) |
SetCustomAttribute(ConstructorInfo, Byte[]) |
Ustawia atrybut niestandardowy przy użyciu określonego obiektu blob atrybutu niestandardowego. |
SetCustomAttribute(CustomAttributeBuilder) |
Ustaw atrybut niestandardowy przy użyciu konstruktora atrybutów niestandardowych. |
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>) |
Po przesłonięciu w klasie pochodnej ustawia atrybut niestandardowy w tym zestawie. |
SetParent(Type) |
Ustawia typ podstawowy typu aktualnie w budowie. |
SetParentCore(Type) |
W przypadku zastąpienia w klasie pochodnej ustawia typ podstawowy typu aktualnie w budowie. |
ToString() |
Zwraca nazwę typu z wyłączeniem przestrzeni nazw. |
Jawne implementacje interfejsu
_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) |
Zestaw nazw jest mapowany na odpowiedni zestaw identyfikatorów wysyłania. (Odziedziczone po MemberInfo) |
_MemberInfo.GetType() |
Pobiera obiekt reprezentujący klasę TypeMemberInfo . (Odziedziczone po MemberInfo) |
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr) |
Pobiera informacje o typie dla obiektu, których następnie można użyć do uzyskania informacji o typie interfejsu. (Odziedziczone po MemberInfo) |
_MemberInfo.GetTypeInfoCount(UInt32) |
Pobiera informację o liczbie typów interfejsów, jakie zawiera obiekt (0 lub 1). (Odziedziczone po MemberInfo) |
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) |
Umożliwia dostęp do właściwości i metod udostępnianych przez obiekt. (Odziedziczone po MemberInfo) |
_Type.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) |
Zestaw nazw jest mapowany na odpowiedni zestaw identyfikatorów wysyłania. (Odziedziczone po Type) |
_Type.GetTypeInfo(UInt32, UInt32, IntPtr) |
Pobiera informacje o typie dla obiektu, których następnie można użyć do uzyskania informacji o typie interfejsu. (Odziedziczone po Type) |
_Type.GetTypeInfoCount(UInt32) |
Pobiera informację o liczbie typów interfejsów, jakie zawiera obiekt (0 lub 1). (Odziedziczone po Type) |
_Type.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) |
Umożliwia dostęp do właściwości i metod udostępnianych przez obiekt. (Odziedziczone po Type) |
_TypeBuilder.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) |
Zestaw nazw jest mapowany na odpowiedni zestaw identyfikatorów wysyłania. |
_TypeBuilder.GetTypeInfo(UInt32, UInt32, IntPtr) |
Pobiera informacje o typie dla obiektu, których następnie można użyć do uzyskania informacji o typie interfejsu. |
_TypeBuilder.GetTypeInfoCount(UInt32) |
Pobiera informację o liczbie typów interfejsów, jakie zawiera obiekt (0 lub 1). |
_TypeBuilder.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) |
Umożliwia dostęp do właściwości i metod udostępnianych przez obiekt. |
ICustomAttributeProvider.GetCustomAttributes(Boolean) |
Zwraca tablicę wszystkich atrybutów niestandardowych zdefiniowanych w tym elemencie członkowskim, z wyłączeniem nazwanych atrybutów lub pustej tablicy, jeśli nie ma atrybutów niestandardowych. (Odziedziczone po MemberInfo) |
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean) |
Zwraca tablicę atrybutów niestandardowych zdefiniowanych na tym elemencie członkowskim, identyfikowaną przez typ lub pustą tablicę, jeśli nie ma atrybutów niestandardowych tego typu. (Odziedziczone po MemberInfo) |
ICustomAttributeProvider.IsDefined(Type, Boolean) |
Wskazuje, czy na tym elemencie członkowskim zdefiniowano jedno lub więcej wystąpień |
IReflectableType.GetTypeInfo() |
Zwraca reprezentację bieżącego typu jako TypeInfo obiektu. (Odziedziczone po TypeInfo) |
Metody rozszerzania
GetCustomAttribute(MemberInfo, Type) |
Pobiera atrybut niestandardowy określonego typu, który jest stosowany do określonego elementu członkowskiego. |
GetCustomAttribute(MemberInfo, Type, Boolean) |
Pobiera atrybut niestandardowy określonego typu, który jest stosowany do określonego elementu członkowskiego, i opcjonalnie sprawdza przodków tego elementu członkowskiego. |
GetCustomAttribute<T>(MemberInfo) |
Pobiera atrybut niestandardowy określonego typu, który jest stosowany do określonego elementu członkowskiego. |
GetCustomAttribute<T>(MemberInfo, Boolean) |
Pobiera atrybut niestandardowy określonego typu, który jest stosowany do określonego elementu członkowskiego, i opcjonalnie sprawdza przodków tego elementu członkowskiego. |
GetCustomAttributes(MemberInfo) |
Pobiera kolekcję atrybutów niestandardowych, które są stosowane do określonego elementu członkowskiego. |
GetCustomAttributes(MemberInfo, Boolean) |
Pobiera kolekcję atrybutów niestandardowych, które są stosowane do określonego elementu członkowskiego, i opcjonalnie sprawdza przodków tego elementu członkowskiego. |
GetCustomAttributes(MemberInfo, Type) |
Pobiera kolekcję atrybutów niestandardowych określonego typu, które są stosowane do określonego elementu członkowskiego. |
GetCustomAttributes(MemberInfo, Type, Boolean) |
Pobiera kolekcję atrybutów niestandardowych określonego typu, które są stosowane do określonego elementu członkowskiego, i opcjonalnie sprawdza przodków tego elementu członkowskiego. |
GetCustomAttributes<T>(MemberInfo) |
Pobiera kolekcję atrybutów niestandardowych określonego typu, które są stosowane do określonego elementu członkowskiego. |
GetCustomAttributes<T>(MemberInfo, Boolean) |
Pobiera kolekcję atrybutów niestandardowych określonego typu, które są stosowane do określonego elementu członkowskiego, i opcjonalnie sprawdza przodków tego elementu członkowskiego. |
IsDefined(MemberInfo, Type) |
Wskazuje, czy atrybuty niestandardowe określonego typu są stosowane do określonego elementu członkowskiego. |
IsDefined(MemberInfo, Type, Boolean) |
Wskazuje, czy atrybuty niestandardowe określonego typu są stosowane do określonego elementu członkowskiego i, opcjonalnie, stosowane do jego elementów nadrzędnych. |
GetTypeInfo(Type) |
Zwraca reprezentację TypeInfo określonego typu. |
GetMetadataToken(MemberInfo) |
Pobiera token metadanych dla danego elementu członkowskiego, jeśli jest dostępny. |
HasMetadataToken(MemberInfo) |
Zwraca wartość wskazującą, czy token metadanych jest dostępny dla określonego elementu członkowskiego. |
GetRuntimeEvent(Type, String) |
Pobiera obiekt reprezentujący określone zdarzenie. |
GetRuntimeEvents(Type) |
Pobiera kolekcję reprezentującą wszystkie zdarzenia zdefiniowane w określonym typie. |
GetRuntimeField(Type, String) |
Pobiera obiekt reprezentujący określone pole. |
GetRuntimeFields(Type) |
Pobiera kolekcję reprezentującą wszystkie pola zdefiniowane w określonym typie. |
GetRuntimeInterfaceMap(TypeInfo, Type) |
Zwraca mapowanie interfejsu dla określonego typu i określonego interfejsu. |
GetRuntimeMethod(Type, String, Type[]) |
Pobiera obiekt reprezentujący określoną metodę. |
GetRuntimeMethods(Type) |
Pobiera kolekcję reprezentującą wszystkie metody zdefiniowane w określonym typie. |
GetRuntimeProperties(Type) |
Pobiera kolekcję reprezentującą wszystkie właściwości zdefiniowane w określonym typie. |
GetRuntimeProperty(Type, String) |
Pobiera obiekt reprezentujący określoną właściwość. |
GetConstructor(Type, Type[]) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
GetConstructors(Type) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
GetConstructors(Type, BindingFlags) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
GetEvents(Type, BindingFlags) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
GetField(Type, String, BindingFlags) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
GetFields(Type) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
GetFields(Type, BindingFlags) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
GetGenericArguments(Type) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
GetInterfaces(Type) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
GetMethod(Type, String) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
GetMethod(Type, String, Type[]) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
GetMethods(Type, BindingFlags) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
GetNestedType(Type, String, BindingFlags) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
GetProperties(Type, BindingFlags) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
GetProperty(Type, String, Type) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
GetProperty(Type, String, Type, Type[]) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
IsAssignableFrom(Type, Type) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
IsInstanceOfType(Type, Object) |
Definiuje i tworzy nowe wystąpienia klas w czasie wykonywania. |
Dotyczy
Zobacz też
Opinia
https://aka.ms/ContentUserFeedback.
Dostępne już wkrótce: W 2024 r. będziemy stopniowo wycofywać zgłoszenia z serwisu GitHub jako mechanizm przesyłania opinii na temat zawartości i zastępować go nowym systemem opinii. Aby uzyskać więcej informacji, sprawdź:Prześlij i wyświetl opinię dla