PersistedAssemblyBuilder Třída

Definice

Obor názvů:: System.Reflection.Emit

Sestavení:: System.Reflection.Emit.dll

Zdroj:: PersistedAssemblyBuilder.cs

Zdroj:: PersistedAssemblyBuilder.cs

Zdroj:: PersistedAssemblyBuilder.cs

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Poskytuje implementaci AssemblyBuilder, která může zachovat sestavení na disk nebo datový proud.

public ref class PersistedAssemblyBuilder sealed : System::Reflection::Emit::AssemblyBuilder

public sealed class PersistedAssemblyBuilder : System.Reflection.Emit.AssemblyBuilder

type PersistedAssemblyBuilder = class
    inherit AssemblyBuilder

Public NotInheritable Class PersistedAssemblyBuilder
Inherits AssemblyBuilder

Dědičnost: Object

Assembly

AssemblyBuilder
PersistedAssemblyBuilder

Poznámky

Rozhraní API AssemblyBuilder.Save se původně nepře portovalo do .NET (Core), protože implementace výrazně závisela na nativním kódu specifickém pro Windows, který nebyl také portován. .NET 9 přidal PersistedAssemblyBuilder třídu, která poskytuje plně spravovanou Reflection.Emit implementaci, která podporuje ukládání. Tato implementace nemá žádnou závislost na existující implementaci Reflection.Emit specifické pro modul runtime. To znamená, že v .NET existují dvě různé implementace: spustitelné a trvalé. Pokud chcete spustit trvalé sestavení, nejprve ho uložte do datového proudu paměti nebo souboru a pak ho načtěte zpět.

Před PersistedAssemblyBuilderbyste mohli spustit pouze vygenerované sestavení a neukládat ho. Vzhledem k tomu, že sestavení bylo pouze uloženo v paměti, bylo obtížné ho odladit. Výhody ukládání dynamického sestavení do souboru jsou:

Vygenerované sestavení můžete ověřit pomocí nástrojů, jako je ILVerify, nebo dekompilovat, a ručně ho prozkoumat pomocí nástrojů, jako je ILSpy.
Uložené sestavení lze načíst přímo, aniž by bylo nutné znovu kompilovat, což může zkrátit dobu spuštění aplikace.

K vytvoření PersistedAssemblyBuilder instance použijte konstruktor PersistedAssemblyBuilder(AssemblyName, Assembly, IEnumerable<CustomAttributeBuilder>). Parametr coreAssembly se používá k řešení základních typů za běhu a lze ho použít k řešení verzování referenčních sestavení.

Pokud Reflection.Emit slouží ke generování sestavení, které se spustí pouze ve stejné verzi modulu runtime jako verze modulu runtime, na které kompilátor běží (obvykle v proc), základní sestavení může být jednoduše typeof(object).Assembly. Následující příklad ukazuje, jak vytvořit a uložit sestavení do datového proudu a spustit ho s aktuálním sestavením runtime:

public static void CreateSaveAndRunAssembly()
{
    PersistedAssemblyBuilder ab = new(new AssemblyName("MyAssembly"), typeof(object).Assembly);
    ModuleBuilder mob = ab.DefineDynamicModule("MyModule");
    TypeBuilder tb = mob.DefineType(
        "MyType",
        TypeAttributes.Public | TypeAttributes.Class);
    MethodBuilder meb = tb.DefineMethod(
        "SumMethod",
        MethodAttributes.Public | MethodAttributes.Static,
        typeof(int), [typeof(int), typeof(int)]);
    ILGenerator il = meb.GetILGenerator();
    il.Emit(OpCodes.Ldarg_0);
    il.Emit(OpCodes.Ldarg_1);
    il.Emit(OpCodes.Add);
    il.Emit(OpCodes.Ret);

    tb.CreateType();

    using var stream = new MemoryStream();
    ab.Save(stream);  // Or pass filename to save into a file.
    stream.Seek(0, SeekOrigin.Begin);
    Assembly assembly = AssemblyLoadContext.Default.LoadFromStream(stream);
    MethodInfo method = assembly.GetType("MyType").GetMethod("SumMethod");
    Console.WriteLine(method.Invoke(null, [5, 10]));
}

Pokud se Reflection.Emit používá k vygenerování sestavení, které cílí na konkrétní TFM, otevřete referenční sestavení pro danou sadu TFM pomocí MetadataLoadContext a použijte hodnotu MetadataLoadContext.CoreAssembly vlastnost pro coreAssembly. Tato hodnota umožňuje generátoru spustit na jedné verzi modulu runtime .NET a cílit na jinou verzi modulu runtime .NET. Při odkazování na základní typy byste měli použít typy vrácené instancí MetadataLoadContext. Například místo typeof(int)vyhledejte typ System.Int32 v MetadataLoadContext.CoreAssembly podle názvu.

public static void CreatePersistedAssemblyBuilderCoreAssemblyWithMetadataLoadContext(string refAssembliesPath)
{
    PathAssemblyResolver resolver = new(Directory.GetFiles(refAssembliesPath, "*.dll"));
    using MetadataLoadContext context = new(resolver);
    Assembly coreAssembly = context.CoreAssembly;
    PersistedAssemblyBuilder ab = new(new AssemblyName("MyDynamicAssembly"), coreAssembly);
    TypeBuilder typeBuilder = ab.DefineDynamicModule("MyModule").DefineType("Test", TypeAttributes.Public);
    MethodBuilder methodBuilder = typeBuilder.DefineMethod("Method", MethodAttributes.Public, coreAssembly.GetType(typeof(int).FullName), Type.EmptyTypes);
    // .. add members and save the assembly
}

Nastavení vstupního bodu pro spustitelný soubor

Chcete-li nastavit vstupní bod spustitelného souboru nebo nastavit další možnosti pro soubor sestavení, můžete volat metodu public MetadataBuilder GenerateMetadata(out BlobBuilder ilStream, out BlobBuilder mappedFieldData) a pomocí vyplněných metadat vygenerovat sestavení s požadovanými možnostmi, například:

public static void SetEntryPoint()
{
    PersistedAssemblyBuilder ab = new(new AssemblyName("MyAssembly"), typeof(object).Assembly);
    TypeBuilder tb = ab.DefineDynamicModule("MyModule").DefineType("MyType", TypeAttributes.Public | TypeAttributes.Class);
    // ...
    MethodBuilder entryPoint = tb.DefineMethod("Main", MethodAttributes.HideBySig | MethodAttributes.Public | MethodAttributes.Static);
    ILGenerator il2 = entryPoint.GetILGenerator();
    // ...
    il2.Emit(OpCodes.Ret);
    tb.CreateType();

    MetadataBuilder metadataBuilder = ab.GenerateMetadata(out BlobBuilder ilStream, out BlobBuilder fieldData);

    ManagedPEBuilder peBuilder = new(
                    header: PEHeaderBuilder.CreateExecutableHeader(),
                    metadataRootBuilder: new MetadataRootBuilder(metadataBuilder),
                    ilStream: ilStream,
                    mappedFieldData: fieldData,
                    entryPoint: MetadataTokens.MethodDefinitionHandle(entryPoint.MetadataToken));

    BlobBuilder peBlob = new();
    peBuilder.Serialize(peBlob);

    // Create the executable:
    using FileStream fileStream = new("MyAssembly.exe", FileMode.Create, FileAccess.Write);
    peBlob.WriteContentTo(fileStream);
}

Generování symbolů a generování PDB

Metadata symbolů se vyplní do výstupního parametru pdbBuilder, když zavoláte metodu GenerateMetadata(BlobBuilder, BlobBuilder) u instance PersistedAssemblyBuilder. Vytvoření sestavení s přenosným souborem PDB:

Pomocí metody ISymbolDocumentWriter vytvořte instance ModuleBuilder.DefineDocument(String, Guid, Guid, Guid). Při generování IL metody rovněž generujte příslušné symbolické informace.
Vytvořte instanci PortablePdbBuilder pomocí instance pdbBuilder vytvořené metodou GenerateMetadata(BlobBuilder, BlobBuilder).
Serializujte PortablePdbBuilder do Bloba zapište Blob do datového proudu souboru PDB (pouze pokud generujete samostatný PDB).
Vytvořte instanci DebugDirectoryBuilder a přidejte DebugDirectoryBuilder.AddCodeViewEntry (samostatný soubor PDB) nebo DebugDirectoryBuilder.AddEmbeddedPortablePdbEntry.
Při vytváření instance debugDirectoryBuilder nastavte volitelný argument PEBuilder.

Následující příklad ukazuje, jak vygenerovat informace o symbolu a vygenerovat soubor PDB.

static void GenerateAssemblyWithPdb()
{
    PersistedAssemblyBuilder ab = new PersistedAssemblyBuilder(new AssemblyName("MyAssembly"), typeof(object).Assembly);
    ModuleBuilder mb = ab.DefineDynamicModule("MyModule");
    TypeBuilder tb = mb.DefineType("MyType", TypeAttributes.Public | TypeAttributes.Class);
    MethodBuilder mb1 = tb.DefineMethod("SumMethod", MethodAttributes.Public | MethodAttributes.Static, typeof(int), [typeof(int), typeof(int)]);
    ISymbolDocumentWriter srcDoc = mb.DefineDocument("MySourceFile.cs", SymLanguageType.CSharp);
    ILGenerator il = mb1.GetILGenerator();
    LocalBuilder local = il.DeclareLocal(typeof(int));
    local.SetLocalSymInfo("myLocal");
    il.MarkSequencePoint(srcDoc, 7, 0, 7, 11);
    ...
    il.Emit(OpCodes.Ret);

    MethodBuilder entryPoint = tb.DefineMethod("Main", MethodAttributes.HideBySig | MethodAttributes.Public | MethodAttributes.Static);
    ILGenerator il2 = entryPoint.GetILGenerator();
    il2.BeginScope();
    ...
    il2.EndScope();
    ...
    tb.CreateType();

    MetadataBuilder metadataBuilder = ab.GenerateMetadata(out BlobBuilder ilStream, out _, out MetadataBuilder pdbBuilder);
    MethodDefinitionHandle entryPointHandle = MetadataTokens.MethodDefinitionHandle(entryPoint.MetadataToken);
    DebugDirectoryBuilder debugDirectoryBuilder = GeneratePdb(pdbBuilder, metadataBuilder.GetRowCounts(), entryPointHandle);

    ManagedPEBuilder peBuilder = new ManagedPEBuilder(
                    header: new PEHeaderBuilder(imageCharacteristics: Characteristics.ExecutableImage, subsystem: Subsystem.WindowsCui),
                    metadataRootBuilder: new MetadataRootBuilder(metadataBuilder),
                    ilStream: ilStream,
                    debugDirectoryBuilder: debugDirectoryBuilder,
                    entryPoint: entryPointHandle);

    BlobBuilder peBlob = new BlobBuilder();
    peBuilder.Serialize(peBlob);

    using var fileStream = new FileStream("MyAssembly.exe", FileMode.Create, FileAccess.Write);
    peBlob.WriteContentTo(fileStream);
}

static DebugDirectoryBuilder GeneratePdb(MetadataBuilder pdbBuilder, ImmutableArray<int> rowCounts, MethodDefinitionHandle entryPointHandle)
{
    BlobBuilder portablePdbBlob = new BlobBuilder();
    PortablePdbBuilder portablePdbBuilder = new PortablePdbBuilder(pdbBuilder, rowCounts, entryPointHandle);
    BlobContentId pdbContentId = portablePdbBuilder.Serialize(portablePdbBlob);
    // In case saving PDB to a file
    using FileStream fileStream = new FileStream("MyAssemblyEmbeddedSource.pdb", FileMode.Create, FileAccess.Write);
    portablePdbBlob.WriteContentTo(fileStream);

    DebugDirectoryBuilder debugDirectoryBuilder = new DebugDirectoryBuilder();
    debugDirectoryBuilder.AddCodeViewEntry("MyAssemblyEmbeddedSource.pdb", pdbContentId, portablePdbBuilder.FormatVersion);
    // In case embedded in PE:
    // debugDirectoryBuilder.AddEmbeddedPortablePdbEntry(portablePdbBlob, portablePdbBuilder.FormatVersion);
    return debugDirectoryBuilder;
}

Dále můžete přidat CustomDebugInformation voláním metody MetadataBuilder.AddCustomDebugInformation(EntityHandle, GuidHandle, BlobHandle) z instance pdbBuilder pro přidání zdrojového vkládání a pokročilé PDB informace o indexování zdroje.

private static void EmbedSource(MetadataBuilder pdbBuilder)
{
    byte[] sourceBytes = File.ReadAllBytes("MySourceFile2.cs");
    BlobBuilder sourceBlob = new BlobBuilder();
    sourceBlob.WriteBytes(sourceBytes);
    pdbBuilder.AddCustomDebugInformation(MetadataTokens.DocumentHandle(1),
        pdbBuilder.GetOrAddGuid(new Guid("0E8A571B-6926-466E-B4AD-8AB04611F5FE")), pdbBuilder.GetOrAddBlob(sourceBlob));
}

Přidání prostředků pomocí PersistedAssemblyBuilder

Můžete volat MetadataBuilder.AddManifestResource(ManifestResourceAttributes, StringHandle, EntityHandle, UInt32) a přidat tolik prostředků, kolik potřebujete. Datové proudy musí být zřetězeny do jednoho BlobBuilder, který pak předáte jako argument ManagedPEBuilder. Následující příklad ukazuje, jak vytvořit prostředky a připojit je k vytvořenému sestavení.

public static void SetResource()
{
    PersistedAssemblyBuilder ab = new(new AssemblyName("MyAssembly"), typeof(object).Assembly);
    ab.DefineDynamicModule("MyModule");
    MetadataBuilder metadata = ab.GenerateMetadata(out BlobBuilder ilStream, out _);

    using MemoryStream stream = new();
    ResourceWriter myResourceWriter = new(stream);
    myResourceWriter.AddResource("AddResource 1", "First added resource");
    myResourceWriter.AddResource("AddResource 2", "Second added resource");
    myResourceWriter.AddResource("AddResource 3", "Third added resource");
    myResourceWriter.Close();

    byte[] data = stream.ToArray();
    BlobBuilder resourceBlob = new();
    resourceBlob.WriteInt32(data.Length);
    resourceBlob.WriteBytes(data);

    metadata.AddManifestResource(
        ManifestResourceAttributes.Public,
        metadata.GetOrAddString("MyResource.resources"),
        implementation: default,
        offset: 0);        

    ManagedPEBuilder peBuilder = new(
                    header: PEHeaderBuilder.CreateLibraryHeader(),
                    metadataRootBuilder: new MetadataRootBuilder(metadata),
                    ilStream: ilStream,
                    managedResources: resourceBlob);

    BlobBuilder blob = new();
    peBuilder.Serialize(blob);

    // Create the assembly:
    using FileStream fileStream = new("MyAssemblyWithResource.dll", FileMode.Create, FileAccess.Write);
    blob.WriteContentTo(fileStream);
}

Následující příklad ukazuje, jak načíst zdroje z vytvořené sestavy.

public static void ReadResource()
{
    Assembly readAssembly = Assembly.LoadFile(Path.Combine(
        Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location),
        "MyAssemblyWithResource.dll"));

    // Use ResourceManager.GetString() to read the resources.
    ResourceManager rm = new("MyResource", readAssembly);
    Console.WriteLine("Using ResourceManager.GetString():");
    Console.WriteLine($"{rm.GetString("AddResource 1", CultureInfo.InvariantCulture)}");
    Console.WriteLine($"{rm.GetString("AddResource 2", CultureInfo.InvariantCulture)}");
    Console.WriteLine($"{rm.GetString("AddResource 3", CultureInfo.InvariantCulture)}");

    // Use ResourceSet to enumerate the resources.
    Console.WriteLine();
    Console.WriteLine("Using ResourceSet:");
    ResourceSet resourceSet = rm.GetResourceSet(CultureInfo.InvariantCulture, createIfNotExists: true, tryParents: false);
    foreach (DictionaryEntry entry in resourceSet)
    {
        Console.WriteLine($"Key: {entry.Key}, Value: {entry.Value}");
    }

    // Use ResourceReader to enumerate the resources.
    Console.WriteLine();
    Console.WriteLine("Using ResourceReader:");
    using Stream stream = readAssembly.GetManifestResourceStream("MyResource.resources")!;
    using ResourceReader reader = new(stream);
    foreach (DictionaryEntry entry in reader)
    {
        Console.WriteLine($"Key: {entry.Key}, Value: {entry.Value}");
    }
}

Note

Tokeny metadat pro všechny členy jsou naplněny při operaci Save. Nepoužívejte tokeny vygenerovaného typu a jeho členů před uložením, protože budou mít výchozí hodnoty nebo vyvolají výjimky. Je bezpečné používat tokeny pro typy, na které se odkazuje, které nejsou generovány.

Některá rozhraní API, která nejsou důležitá pro generování sestavení, nejsou implementována. například GetCustomAttributes() není implementováno. Při implementaci modulu runtime jste po vytvoření typu mohli tato rozhraní API použít. U trvalých AssemblyBuildervyhodí NotSupportedException nebo NotImplementedException. Pokud máte scénář, který vyžaduje tato rozhraní API, vytvořte problém v úložišti dotnet/runtime.

Pro alternativní způsob, jak generovat soubory sestavení, se podívejte na MetadataBuilder.

Warning

PersistedAssemblyBuilder Rozhraní API vyžadují plně důvěryhodné prostředí s důvěryhodným vstupem, podobně jako jiné technologie, jako jsou kompilátory. Neexistují žádná omezení než základní ověřování vygenerovaných il, které AssemblyBuilder může obsahovat. To zahrnuje ověření názvu člena, počtu a přidružených metadat, jako jsou vlastní atributy.

Konstruktory

Name	Description
PersistedAssemblyBuilder(AssemblyName, Assembly, IEnumerable<CustomAttributeBuilder>)	PersistedAssemblyBuilder Vytvoří instanci, která se dá uložit do souboru nebo datového proudu.

Vlastnosti

Name	Description
CodeBase	Zastaralé. Získá umístění sestavení, jak bylo zadáno původně (například v objektu AssemblyName ). (Zděděno od AssemblyBuilder)
CustomAttributes	Získá kolekci, která obsahuje vlastní atributy tohoto sestavení. (Zděděno od Assembly)
EntryPoint	Vrátí vstupní bod tohoto sestavení. (Zděděno od AssemblyBuilder)
EscapedCodeBase	Zastaralé. Zastaralé. Získá identifikátor URI, včetně řídicích znaků, který představuje základ kódu. (Zděděno od Assembly)
ExportedTypes	Získá kolekci veřejných typů definovaných v tomto sestavení, které jsou viditelné mimo sestavení. (Zděděno od Assembly)
FullName	Získá zobrazovaný název aktuální dynamické sestavení.
HostContext	Získá kontext hostitele, kde se vytváří dynamické sestavení. (Zděděno od AssemblyBuilder)
IsCollectible	Získá hodnotu, která určuje, zda je toto dynamické sestavení uloženo v collectible AssemblyLoadContext. (Zděděno od AssemblyBuilder)
IsDynamic	Získá hodnotu, která označuje, že aktuální sestavení je dynamické sestavení. (Zděděno od AssemblyBuilder)
IsFullyTrusted	Získá hodnotu, která určuje, zda je aktuální sestavení načteno s úplným vztahem důvěryhodnosti. (Zděděno od Assembly)
Location	Získá umístění ve formátu základu kódu načteného souboru, který obsahuje manifest, pokud není stínově zkopírován. (Zděděno od AssemblyBuilder)
ManifestModule	Získá modul v aktuálním PersistedAssemblyBuilder , který obsahuje manifest sestavení.
ReflectionOnly	Získá hodnotu určující, zda dynamické sestavení je v kontextu jen reflexe. (Zděděno od AssemblyBuilder)

Metody

Name	Description
CreateInstance(String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])	Vyhledá zadaný typ z tohoto sestavení a vytvoří jeho instanci pomocí aktivátoru systému, s volitelným vyhledáváním s rozlišováním velkých a malých písmen a se zadanými jazykovými verzemi, argumenty a atributy vazby a aktivace. (Zděděno od Assembly)
CreateInstance(String, Boolean)	Vyhledá zadaný typ z tohoto sestavení a vytvoří instanci pomocí aktivátoru systému s volitelným vyhledáváním s rozlišováním velkých a malých písmen. (Zděděno od Assembly)
CreateInstance(String)	Vyhledá zadaný typ z tohoto sestavení a vytvoří jeho instanci pomocí aktivátoru systému pomocí vyhledávání s rozlišováním velkých a malých písmen. (Zděděno od Assembly)
DefineDynamicModule(String)	Definuje pojmenovaný přechodný dynamický modul v tomto sestavení. (Zděděno od AssemblyBuilder)
DefineDynamicModuleCore(String)	Při přepsání v odvozené třídě definuje dynamický modul v tomto sestavení. (Zděděno od AssemblyBuilder)
Equals(Object)	Vrátí hodnotu, která určuje, zda je tato instance rovna zadanému objektu. (Zděděno od AssemblyBuilder)
GenerateMetadata(BlobBuilder, BlobBuilder, MetadataBuilder)	Vygeneruje metadata pro objekt PersistedAssemblyBuilder.
GenerateMetadata(BlobBuilder, BlobBuilder)	Vygeneruje metadata pro objekt PersistedAssemblyBuilder.
GetCustomAttributes(Boolean)	Vrátí všechny vlastní atributy, které byly použity na aktuální AssemblyBuilder. (Zděděno od AssemblyBuilder)
GetCustomAttributes(Type, Boolean)	Vrátí všechny vlastní atributy, které byly použity na aktuální AssemblyBuildera které jsou odvozeny od zadaného typu atributu. (Zděděno od AssemblyBuilder)
GetCustomAttributesData()	Vrátí CustomAttributeData objekty obsahující informace o atributech, které byly použity na aktuální AssemblyBuilder. (Zděděno od AssemblyBuilder)
GetDynamicModule(String)	Vrátí dynamický modul se zadaným názvem. (Zděděno od AssemblyBuilder)
GetDynamicModuleCore(String)	Při přepsání v odvozené třídě vrátí dynamický modul se zadaným názvem. (Zděděno od AssemblyBuilder)
GetExportedTypes()	Získá exportované typy definované v tomto sestavení. (Zděděno od AssemblyBuilder)
GetFile(String)	FileStream Získá pro zadaný soubor v tabulce souboru manifestu tohoto sestavení. (Zděděno od AssemblyBuilder)
GetFiles()	Získá soubory v tabulce souboru manifestu sestavení. (Zděděno od Assembly)
GetFiles(Boolean)	Získá soubory v tabulce souboru manifestu sestavení určující, zda se mají zahrnout moduly prostředků. (Zděděno od AssemblyBuilder)
GetForwardedTypes()	Poskytuje implementaci AssemblyBuilder, která může zachovat sestavení na disk nebo datový proud. (Zděděno od Assembly)
GetHashCode()	Vrátí kód hash pro tuto instanci. (Zděděno od AssemblyBuilder)
GetLoadedModules()	Získá všechny načtené moduly, které jsou součástí tohoto sestavení. (Zděděno od Assembly)
GetLoadedModules(Boolean)	Vrátí všechny načtené moduly, které jsou součástí tohoto sestavení, a volitelně obsahuje moduly prostředků. (Zděděno od AssemblyBuilder)
GetManifestResourceInfo(String)	Vrátí informace o tom, jak byl daný prostředek zachován. (Zděděno od AssemblyBuilder)
GetManifestResourceNames()	Načte zadaný prostředek manifestu z tohoto sestavení. (Zděděno od AssemblyBuilder)
GetManifestResourceStream(String)	Načte zadaný prostředek manifestu z tohoto sestavení. (Zděděno od AssemblyBuilder)
GetManifestResourceStream(Type, String)	Načte zadaný prostředek manifestu vymezený oborem názvů zadaného typu z tohoto sestavení. (Zděděno od AssemblyBuilder)
GetModule(String)	Získá zadaný modul v tomto sestavení. (Zděděno od AssemblyBuilder)
GetModules()	Získá všechny moduly, které jsou součástí tohoto sestavení. (Zděděno od Assembly)
GetModules(Boolean)	Získá všechny moduly, které jsou součástí tohoto sestavení, a volitelně zahrnuje moduly prostředků. (Zděděno od AssemblyBuilder)
GetName()	AssemblyName Získá pro toto sestavení. (Zděděno od Assembly)
GetName(Boolean)	AssemblyName Získá zadaný, který byl zadán při vytvoření aktuální dynamické sestavení.
GetObjectData(SerializationInfo, StreamingContext)	Zastaralé. Získá serializační informace se všemi daty potřebnými k obnovení tohoto sestavení. (Zděděno od Assembly)
GetReferencedAssemblies()	Získá neúplný seznam AssemblyName objektů pro sestavení, které jsou odkazovány tímto AssemblyBuilder. (Zděděno od AssemblyBuilder)
GetSatelliteAssembly(CultureInfo, Version)	Získá zadanou verzi satelitního sestavení pro zadanou jazykovou verzi. (Zděděno od AssemblyBuilder)
GetSatelliteAssembly(CultureInfo)	Získá satelitní sestavení pro zadanou jazykovou verzi. (Zděděno od AssemblyBuilder)
GetType(String, Boolean, Boolean)	Získá zadaný typ z typů, které byly definovány a vytvořeny v aktuální AssemblyBuilder. (Zděděno od AssemblyBuilder)
GetType(String, Boolean)	Type Získá objekt se zadaným názvem v instanci sestavení a volitelně vyvolá výjimku, pokud typ nebyl nalezen. (Zděděno od Assembly)
GetType(String)	Type Získá objekt se zadaným názvem v instanci sestavení. (Zděděno od Assembly)
GetTypes()	Získá všechny typy definované v tomto sestavení. (Zděděno od Assembly)
IsDefined(Type, Boolean)	Vrátí hodnotu, která určuje, zda je pro tohoto člena použita jedna nebo více instancí zadaného typu atributu. (Zděděno od AssemblyBuilder)
LoadModule(String, Byte[], Byte[])	Načte modul, interní do tohoto sestavení, s obrázkem založeným na společném formátu souboru objektu (COFF), který obsahuje vygenerovaný modul nebo soubor prostředků. Načtou se také nezpracované bajty představující symboly modulu. (Zděděno od Assembly)
LoadModule(String, Byte[])	Načte modul, interní do tohoto sestavení, s obrázkem založeným na společném formátu souboru objektu (COFF), který obsahuje vygenerovaný modul nebo soubor prostředků. (Zděděno od Assembly)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (Zděděno od Object)
Save(Stream)	Serializuje sestavení do zadaného datového proudu.
Save(String)	Uloží sestavení na disk.
SetCustomAttribute(ConstructorInfo, Byte[])	Nastavte pro toto sestavení vlastní atribut pomocí zadaného objektu blob vlastního atributu. (Zděděno od AssemblyBuilder)
SetCustomAttribute(CustomAttributeBuilder)	Nastavte pro toto sestavení vlastní atribut pomocí vlastního tvůrce atributů. (Zděděno od AssemblyBuilder)
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Při přepsání v odvozené třídě nastaví vlastní atribut pro toto sestavení. (Zděděno od AssemblyBuilder)
ToString()	Vrátí úplný název sestavení, označovaný také jako zobrazovaný název. (Zděděno od Assembly)

Událost

Name	Description
ModuleResolve	Nastane, když zavaděč třídy common language runtime nemůže přeložit odkaz na interní modul sestavení pomocí normálních prostředků. (Zděděno od Assembly)

Metody rozšíření

Name	Description
GetCustomAttribute(Assembly, Type)	Načte vlastní atribut zadaného typu, který se použije na zadané sestavení.
GetCustomAttribute<T>(Assembly)	Načte vlastní atribut zadaného typu, který se použije na zadané sestavení.
GetCustomAttributes(Assembly, Type)	Načte kolekci vlastních atributů zadaného typu, které se použijí na zadané sestavení.
GetCustomAttributes(Assembly)	Načte kolekci vlastních atributů, které se použijí na zadané sestavení.
GetCustomAttributes<T>(Assembly)	Načte kolekci vlastních atributů zadaného typu, které se použijí na zadané sestavení.
GetExportedTypes(Assembly)	Poskytuje implementaci AssemblyBuilder, která může zachovat sestavení na disk nebo datový proud.
GetModules(Assembly)	Poskytuje implementaci AssemblyBuilder, která může zachovat sestavení na disk nebo datový proud.
GetTypes(Assembly)	Poskytuje implementaci AssemblyBuilder, která může zachovat sestavení na disk nebo datový proud.
IsDefined(Assembly, Type)	Určuje, zda jsou vlastní atributy zadaného typu použity na zadané sestavení.
TryGetRawMetadata(Assembly, Byte*, Int32)	Načte část metadat sestavení pro použití s MetadataReader.

Platí pro

Váš názor

Byla tato stránka užitečná?