Partager via


AppDomain.DefineDynamicAssembly Méthode

Définition

Définit un assembly dynamique dans le domaine d'application actuel.

Surcharges

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean, IEnumerable<CustomAttributeBuilder>)
Obsolète.

Définit un assembly dynamique avec le nom, le mode d’accès, le répertoire de stockage, la preuve, les demandes d’autorisations, l’option de synchronisation et les attributs personnalisés spécifiés.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean)
Obsolète.

Définit un assembly dynamique avec le nom, le mode d'accès, le répertoire de stockage, la preuve, les demandes d'autorisations et l'option de synchronisation spécifiés.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet)
Obsolète.

Définit un assembly dynamique avec le nom, le mode d'accès, le répertoire de stockage, la preuve et les demandes d'autorisations spécifiés.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, PermissionSet, PermissionSet, PermissionSet)
Obsolète.

Définit un assembly dynamique avec le nom, le mode d'accès, le répertoire de stockage et les demandes d'autorisations spécifiés.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, Evidence, PermissionSet, PermissionSet, PermissionSet)
Obsolète.

Définit un assembly dynamique avec le nom, le mode d'accès, la preuve et les demandes d'autorisations spécifiés.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Boolean, IEnumerable<CustomAttributeBuilder>)

Définit un assembly dynamique avec le nom, le mode d'accès, le répertoire de stockage et l'option de synchronisation spécifiés.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, PermissionSet, PermissionSet, PermissionSet)
Obsolète.

Définit un assembly dynamique avec le nom, le mode d'accès et les demandes d'autorisations spécifiés.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence)
Obsolète.

Définit un assembly dynamique avec le nom, le mode d'accès, le répertoire de stockage et la preuve spécifiés.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, IEnumerable<CustomAttributeBuilder>, SecurityContextSource)

Définit un assembly dynamique avec le nom, le mode d'accès et les attributs personnalisés spécifiés, à l'aide de la source indiquée pour son contexte de sécurité.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String)

Définit un assembly dynamique avec le nom, le mode d'accès et le répertoire de stockage spécifiés.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, Evidence)
Obsolète.

Définit un assembly dynamique avec le nom, le mode d'accès et la preuve spécifiés.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, IEnumerable<CustomAttributeBuilder>)

Définit un assembly dynamique avec le nom, le mode d'accès et les attributs personnalisés spécifiés.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess)

Définit un assembly dynamique avec le nom et le mode d'accès spécifiés.

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean, IEnumerable<CustomAttributeBuilder>)

Attention

Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.

Définit un assembly dynamique avec le nom, le mode d’accès, le répertoire de stockage, la preuve, les demandes d’autorisations, l’option de synchronisation et les attributs personnalisés spécifiés.

public:
 System::Reflection::Emit::AssemblyBuilder ^ DefineDynamicAssembly(System::Reflection::AssemblyName ^ name, System::Reflection::Emit::AssemblyBuilderAccess access, System::String ^ dir, System::Security::Policy::Evidence ^ evidence, System::Security::PermissionSet ^ requiredPermissions, System::Security::PermissionSet ^ optionalPermissions, System::Security::PermissionSet ^ refusedPermissions, bool isSynchronized, System::Collections::Generic::IEnumerable<System::Reflection::Emit::CustomAttributeBuilder ^> ^ assemblyAttributes);
public System.Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (System.Reflection.AssemblyName name, System.Reflection.Emit.AssemblyBuilderAccess access, string dir, System.Security.Policy.Evidence evidence, System.Security.PermissionSet requiredPermissions, System.Security.PermissionSet optionalPermissions, System.Security.PermissionSet refusedPermissions, bool isSynchronized, System.Collections.Generic.IEnumerable<System.Reflection.Emit.CustomAttributeBuilder> assemblyAttributes);
[System.Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
public System.Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (System.Reflection.AssemblyName name, System.Reflection.Emit.AssemblyBuilderAccess access, string dir, System.Security.Policy.Evidence evidence, System.Security.PermissionSet requiredPermissions, System.Security.PermissionSet optionalPermissions, System.Security.PermissionSet refusedPermissions, bool isSynchronized, System.Collections.Generic.IEnumerable<System.Reflection.Emit.CustomAttributeBuilder> assemblyAttributes);
member this.DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * string * System.Security.Policy.Evidence * System.Security.PermissionSet * System.Security.PermissionSet * System.Security.PermissionSet * bool * seq<System.Reflection.Emit.CustomAttributeBuilder> -> System.Reflection.Emit.AssemblyBuilder
[<System.Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")>]
member this.DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * string * System.Security.Policy.Evidence * System.Security.PermissionSet * System.Security.PermissionSet * System.Security.PermissionSet * bool * seq<System.Reflection.Emit.CustomAttributeBuilder> -> System.Reflection.Emit.AssemblyBuilder
Public Function DefineDynamicAssembly (name As AssemblyName, access As AssemblyBuilderAccess, dir As String, evidence As Evidence, requiredPermissions As PermissionSet, optionalPermissions As PermissionSet, refusedPermissions As PermissionSet, isSynchronized As Boolean, assemblyAttributes As IEnumerable(Of CustomAttributeBuilder)) As AssemblyBuilder

Paramètres

name
AssemblyName

Identité unique de l'assembly dynamique.

access
AssemblyBuilderAccess

Mode d'accès à l'assembly dynamique.

dir
String

Nom du répertoire dans lequel l'assembly dynamique doit être enregistré. Si dir est null, le répertoire actif est utilisé.

evidence
Evidence

Preuve fournie pour l'assembly dynamique. La preuve est utilisée non modifiée en tant qu’ensemble de preuves final pour la résolution de stratégie.

requiredPermissions
PermissionSet

Demande d'autorisations requises.

optionalPermissions
PermissionSet

Demande d'autorisations facultatives.

refusedPermissions
PermissionSet

Demande d'autorisations refusées.

isSynchronized
Boolean

true pour synchroniser la création de modules, de types et de membres dans l'assembly dynamique ; sinon, false.

assemblyAttributes
IEnumerable<CustomAttributeBuilder>

Une liste enumérable d'attributs à appliquer à l'assembly, ou null s'il n'y a pas d'attributs.

Retours

Assembly dynamique avec le nom et les fonctionnalités spécifiés.

Attributs

Exceptions

name a la valeur null.

La propriété Name de name a la valeur null.

- ou -

La propriété Name de name commence par un espace blanc ou bien contient une barre oblique ou une barre oblique inverse.

L’opération est tentée sur un domaine d’application non chargé.

Remarques

Utilisez cette surcharge de méthode pour spécifier des attributs qui ne fonctionnent pas correctement, sauf s’ils sont appliqués lors de la création d’un assembly dynamique. Par exemple, les attributs de sécurité tels que SecurityTransparentAttribute et SecurityCriticalAttribute ne fonctionnent pas correctement s’ils sont ajoutés après la création d’un assembly dynamique.

Les demandes d’autorisation spécifiées pour les requiredPermissionsparamètres , optionalPermissionset refusedPermissions sont utilisées uniquement si le evidence paramètre est également fourni ou si l’assembly dynamique est enregistré et rechargé en mémoire.

Notes

Lorsque vous développez du code qui émet des assemblys dynamiques, nous vous recommandons d’inclure l’indicateur SecurityPermissionFlag.SkipVerification dans le refusedPermissions paramètre. L’inclusion de cet indicateur garantit que le langage intermédiaire Microsoft (MSIL) sera vérifié. Cette technique détecte la génération involontaire de code non vérifiable, ce qui est sinon très difficile à détecter. Une limitation de cette technique est qu’elle provoque SecurityException également la levée lorsqu’elle est utilisée avec du code qui exige une confiance totale.

Seuls les appelants entièrement approuvés peuvent fournir des preuves lors de la définition d’un élément dynamique Assembly. Le runtime mappe le Evidence via la stratégie de sécurité pour déterminer les autorisations accordées. Les appelants partiellement approuvés doivent fournir null pour le evidence paramètre. Si evidence a la valeur null, le runtime copie les jeux d’autorisations (c’est-à-dire les jeux d’octroi et de refus actuels) de l’assembly de l’appelant vers l’assembly dynamique en cours de définition, et marque la stratégie comme résolue.

Si l’assembly dynamique est enregistré sur le disque, les charges suivantes obtiennent des subventions en fonction des stratégies associées à l’emplacement où l’assembly dynamique a été enregistré.

Si isSynchronized a la valeur true, les méthodes suivantes du résultat AssemblyBuilder seront synchronisées : DefineDynamicModule, DefineResource, AddResourceFile, GetDynamicModule, , SetEntryPointet Save. Si deux de ces méthodes sont appelées sur des threads différents, l’une est bloquée jusqu’à ce que l’autre soit terminée.

Cette surcharge de méthode est introduite dans .NET Framework 3.5.

Voir aussi

S’applique à

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean)

Attention

Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.

Définit un assembly dynamique avec le nom, le mode d'accès, le répertoire de stockage, la preuve, les demandes d'autorisations et l'option de synchronisation spécifiés.

public:
 virtual System::Reflection::Emit::AssemblyBuilder ^ DefineDynamicAssembly(System::Reflection::AssemblyName ^ name, System::Reflection::Emit::AssemblyBuilderAccess access, System::String ^ dir, System::Security::Policy::Evidence ^ evidence, System::Security::PermissionSet ^ requiredPermissions, System::Security::PermissionSet ^ optionalPermissions, System::Security::PermissionSet ^ refusedPermissions, bool isSynchronized);
public System.Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (System.Reflection.AssemblyName name, System.Reflection.Emit.AssemblyBuilderAccess access, string dir, System.Security.Policy.Evidence evidence, System.Security.PermissionSet requiredPermissions, System.Security.PermissionSet optionalPermissions, System.Security.PermissionSet refusedPermissions, bool isSynchronized);
[System.Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
public System.Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (System.Reflection.AssemblyName name, System.Reflection.Emit.AssemblyBuilderAccess access, string dir, System.Security.Policy.Evidence evidence, System.Security.PermissionSet requiredPermissions, System.Security.PermissionSet optionalPermissions, System.Security.PermissionSet refusedPermissions, bool isSynchronized);
abstract member DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * string * System.Security.Policy.Evidence * System.Security.PermissionSet * System.Security.PermissionSet * System.Security.PermissionSet * bool -> System.Reflection.Emit.AssemblyBuilder
override this.DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * string * System.Security.Policy.Evidence * System.Security.PermissionSet * System.Security.PermissionSet * System.Security.PermissionSet * bool -> System.Reflection.Emit.AssemblyBuilder
[<System.Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")>]
abstract member DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * string * System.Security.Policy.Evidence * System.Security.PermissionSet * System.Security.PermissionSet * System.Security.PermissionSet * bool -> System.Reflection.Emit.AssemblyBuilder
override this.DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * string * System.Security.Policy.Evidence * System.Security.PermissionSet * System.Security.PermissionSet * System.Security.PermissionSet * bool -> System.Reflection.Emit.AssemblyBuilder
Public Function DefineDynamicAssembly (name As AssemblyName, access As AssemblyBuilderAccess, dir As String, evidence As Evidence, requiredPermissions As PermissionSet, optionalPermissions As PermissionSet, refusedPermissions As PermissionSet, isSynchronized As Boolean) As AssemblyBuilder

Paramètres

name
AssemblyName

Identité unique de l'assembly dynamique.

access
AssemblyBuilderAccess

Mode d'accès à l'assembly dynamique.

dir
String

Nom du répertoire dans lequel l'assembly dynamique doit être enregistré. Si dir est null, le répertoire actif est utilisé comme répertoire par défaut.

evidence
Evidence

Preuve fournie pour l'assembly dynamique. La preuve est utilisée non modifiée en tant qu’ensemble de preuves final pour la résolution de stratégie.

requiredPermissions
PermissionSet

Demande d'autorisations requises.

optionalPermissions
PermissionSet

Demande d'autorisations facultatives.

refusedPermissions
PermissionSet

Demande d'autorisations refusées.

isSynchronized
Boolean

true pour synchroniser la création de modules, de types et de membres dans l'assembly dynamique ; sinon, false.

Retours

Assembly dynamique avec le nom et les fonctionnalités spécifiés.

Implémente

Attributs

Exceptions

name a la valeur null.

La propriété Name de name a la valeur null.

- ou -

La propriété Name de name commence par un espace blanc ou contient une barre oblique ou une barre oblique inverse.

L’opération est tentée sur un domaine d’application non chargé.

Exemples

L’exemple suivant illustre la méthode et l’événement DefineDynamicAssemblyAssemblyResolve .

Pour que cet exemple de code s’exécute, vous devez fournir le nom complet de l’assembly. Pour plus d’informations sur la façon d’obtenir le nom complet de l’assembly, consultez Noms d’assembly.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
ref class Test
{
public:
   static void InstantiateMyDynamicType( AppDomain^ domain )
   {
      try
      {
         
         // You must supply a valid fully qualified assembly name here.
         domain->CreateInstance( "Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType" );
      }
      catch ( Exception^ e ) 
      {
         Console::WriteLine( e->Message );
      }

   }

   static Assembly^ MyResolveEventHandler( Object^ sender, ResolveEventArgs^ args )
   {
      return DefineDynamicAssembly( dynamic_cast<AppDomain^>(sender) );
   }

   static Assembly^ DefineDynamicAssembly( AppDomain^ domain )
   {
      
      // Build a dynamic assembly using Reflection Emit API.
      AssemblyName^ assemblyName = gcnew AssemblyName;
      assemblyName->Name = "MyDynamicAssembly";
      AssemblyBuilder^ assemblyBuilder = domain->DefineDynamicAssembly( assemblyName, AssemblyBuilderAccess::Run );
      ModuleBuilder^ moduleBuilder = assemblyBuilder->DefineDynamicModule( "MyDynamicModule" );
      TypeBuilder^ typeBuilder = moduleBuilder->DefineType( "MyDynamicType", TypeAttributes::Public );
      ConstructorBuilder^ constructorBuilder = typeBuilder->DefineConstructor( MethodAttributes::Public, CallingConventions::Standard, nullptr );
      ILGenerator^ ilGenerator = constructorBuilder->GetILGenerator();
      ilGenerator->EmitWriteLine( "MyDynamicType instantiated!" );
      ilGenerator->Emit( OpCodes::Ret );
      typeBuilder->CreateType();
      return assemblyBuilder;
   }

};

int main()
{
   AppDomain^ currentDomain = AppDomain::CurrentDomain;
   Test::InstantiateMyDynamicType( currentDomain ); // Failed!
   currentDomain->AssemblyResolve += gcnew ResolveEventHandler( Test::MyResolveEventHandler );
   Test::InstantiateMyDynamicType( currentDomain ); // OK!
}
using System;
using System.Reflection;
using System.Reflection.Emit;

class DefinedDynamicAssemblySnippet {
   public static void Main() {
      AppDomain currentDomain = AppDomain.CurrentDomain;

      InstantiateMyDynamicType(currentDomain);   // Failed!

      currentDomain.AssemblyResolve += new ResolveEventHandler(MyResolveEventHandler);

      InstantiateMyDynamicType(currentDomain);   // OK!
   }

   static void InstantiateMyDynamicType(AppDomain domain) {
      try {
         // You must supply a valid fully qualified assembly name here.
         domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType");
      } catch (Exception e) {
         Console.WriteLine(e.Message);
      }
   }

   static Assembly MyResolveEventHandler(object sender, ResolveEventArgs args) {
      return DefineDynamicAssembly((AppDomain) sender);
   }

   static Assembly DefineDynamicAssembly(AppDomain domain) {
      // Build a dynamic assembly using Reflection Emit API.

      AssemblyName assemblyName = new AssemblyName();
      assemblyName.Name = "MyDynamicAssembly";

      AssemblyBuilder assemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
      ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("MyDynamicModule");
      TypeBuilder typeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public);
      ConstructorBuilder constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, null);
      ILGenerator ilGenerator = constructorBuilder.GetILGenerator();

      ilGenerator.EmitWriteLine("MyDynamicType instantiated!");
      ilGenerator.Emit(OpCodes.Ret);

      typeBuilder.CreateType();

      return assemblyBuilder;
   }
}
open System
open System.Reflection
open System.Reflection.Emit

let instantiateMyDynamicType (domain: AppDomain) =
    try
        // You must supply a valid fully qualified assembly name here.
        domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType")
        |> ignore
    with e ->
        printfn $"{e.Message}"

let defineDynamicAssembly (domain: AppDomain) =
    // Build a dynamic assembly using Reflection Emit API.
    let assemblyName = AssemblyName()
    assemblyName.Name <- "MyDynamicAssembly"

    let assemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run)
    let moduleBuilder = assemblyBuilder.DefineDynamicModule "MyDynamicModule"
    let typeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public)
    let constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, null)
    let ilGenerator = constructorBuilder.GetILGenerator()

    ilGenerator.EmitWriteLine "MyDynamicType instantiated!"
    ilGenerator.Emit OpCodes.Ret

    typeBuilder.CreateType() |> ignore

    assemblyBuilder

let myResolveEventHandler (sender: obj) _ =
    defineDynamicAssembly (sender :?> AppDomain)
    :> Assembly
   
let currentDomain = AppDomain.CurrentDomain

instantiateMyDynamicType currentDomain   // Failed!

currentDomain.add_AssemblyResolve(ResolveEventHandler myResolveEventHandler)

instantiateMyDynamicType currentDomain   // OK!

Imports System.Reflection
Imports System.Reflection.Emit

Module Test
   
   Sub Main()
      Dim currentDomain As AppDomain = AppDomain.CurrentDomain
      
      InstantiateMyDynamicType(currentDomain)   'Failed!
      
      AddHandler currentDomain.AssemblyResolve, AddressOf MyResolveEventHandler
      
      InstantiateMyDynamicType(currentDomain)   'OK!
   End Sub
   
   Sub InstantiateMyDynamicType(domain As AppDomain)
      Try
         ' You must supply a valid fully qualified assembly name here.
         domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType")
      Catch e As Exception
         Console.WriteLine(e.Message)
      End Try
   End Sub
   
   Function MyResolveEventHandler(sender As Object, args As ResolveEventArgs) As System.Reflection.Assembly
      Return DefineDynamicAssembly(DirectCast(sender, AppDomain))
   End Function 'MyResolveEventHandler
   
   Function DefineDynamicAssembly(domain As AppDomain) As System.Reflection.Assembly
      ' Build a dynamic assembly using Reflection Emit API.

      Dim assemblyName As New AssemblyName()
      assemblyName.Name = "MyDynamicAssembly"
      
      Dim assemblyBuilder As AssemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run)
      Dim moduleBuilder As ModuleBuilder = assemblyBuilder.DefineDynamicModule("MyDynamicModule")
      Dim typeBuilder As TypeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public)
      Dim constructorBuilder As ConstructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Nothing)
      Dim ilGenerator As ILGenerator = constructorBuilder.GetILGenerator()
      
      ilGenerator.EmitWriteLine("MyDynamicType instantiated!")
      ilGenerator.Emit(OpCodes.Ret)
      
      typeBuilder.CreateType()
      
      Return assemblyBuilder
   End Function 'DefineDynamicAssembly

End Module 'Test

Remarques

Les demandes d’autorisation spécifiées pour requiredPermissions, optionalPermissionset refusedPermissions ne sont utilisées que si evidence est également fourni ou si l’assembly dynamique est enregistré et rechargé en mémoire.

Notes

Lors du développement de code qui émet des assemblys dynamiques, il est recommandé d’inclure SecurityPermissionFlag.SkipVerification dans refusedPermissions. L’inclusion SkipVerification dans le refusedPermissions paramètre garantit que le MSIL est vérifié. Une limitation de cette technique est qu’elle provoque également la SecurityException levée lorsqu’elle est utilisée avec du code qui demande une confiance totale.

Seuls les appelants entièrement fiables peuvent fournir leurs preuves lors de la définition d’un élément dynamique Assembly. Le runtime mappe le Evidence via la stratégie de sécurité pour déterminer les autorisations accordées. Les appelants partiellement approuvés doivent fournir null pour le evidence paramètre. Si evidence a la valeur null, le runtime copie les jeux d’autorisations, c’est-à-dire les jeux d’octroi et de refus actuels, de l’appelant Assembly à la dynamique Assembly en cours de définition et marque la stratégie comme résolue.

Si la dynamique Assembly est enregistrée sur le disque, les charges suivantes recevront des subventions en fonction des stratégies associées à l’emplacement où le Assembly a été enregistré.

Si isSynchronized a la valeur true, les méthodes suivantes du résultat AssemblyBuilder seront synchronisées : DefineDynamicModule, DefineResource, AddResourceFile, GetDynamicModule, , SetEntryPointet Save. Si deux de ces méthodes sont appelées sur des threads différents, l’une est bloquée jusqu’à ce que l’autre se termine.

S’applique à

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet)

Attention

Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. Please see http://go.microsoft.com/fwlink/?LinkId=155570 for more information.

Définit un assembly dynamique avec le nom, le mode d'accès, le répertoire de stockage, la preuve et les demandes d'autorisations spécifiés.

public:
 virtual System::Reflection::Emit::AssemblyBuilder ^ DefineDynamicAssembly(System::Reflection::AssemblyName ^ name, System::Reflection::Emit::AssemblyBuilderAccess access, System::String ^ dir, System::Security::Policy::Evidence ^ evidence, System::Security::PermissionSet ^ requiredPermissions, System::Security::PermissionSet ^ optionalPermissions, System::Security::PermissionSet ^ refusedPermissions);
public System.Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (System.Reflection.AssemblyName name, System.Reflection.Emit.AssemblyBuilderAccess access, string dir, System.Security.Policy.Evidence evidence, System.Security.PermissionSet requiredPermissions, System.Security.PermissionSet optionalPermissions, System.Security.PermissionSet refusedPermissions);
[System.Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default.  Please see http://go.microsoft.com/fwlink/?LinkId=155570 for more information.")]
public System.Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (System.Reflection.AssemblyName name, System.Reflection.Emit.AssemblyBuilderAccess access, string dir, System.Security.Policy.Evidence evidence, System.Security.PermissionSet requiredPermissions, System.Security.PermissionSet optionalPermissions, System.Security.PermissionSet refusedPermissions);
abstract member DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * string * System.Security.Policy.Evidence * System.Security.PermissionSet * System.Security.PermissionSet * System.Security.PermissionSet -> System.Reflection.Emit.AssemblyBuilder
override this.DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * string * System.Security.Policy.Evidence * System.Security.PermissionSet * System.Security.PermissionSet * System.Security.PermissionSet -> System.Reflection.Emit.AssemblyBuilder
[<System.Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default.  Please see http://go.microsoft.com/fwlink/?LinkId=155570 for more information.")>]
abstract member DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * string * System.Security.Policy.Evidence * System.Security.PermissionSet * System.Security.PermissionSet * System.Security.PermissionSet -> System.Reflection.Emit.AssemblyBuilder
override this.DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * string * System.Security.Policy.Evidence * System.Security.PermissionSet * System.Security.PermissionSet * System.Security.PermissionSet -> System.Reflection.Emit.AssemblyBuilder
Public Function DefineDynamicAssembly (name As AssemblyName, access As AssemblyBuilderAccess, dir As String, evidence As Evidence, requiredPermissions As PermissionSet, optionalPermissions As PermissionSet, refusedPermissions As PermissionSet) As AssemblyBuilder

Paramètres

name
AssemblyName

Identité unique de l'assembly dynamique.

access
AssemblyBuilderAccess

Mode d'accès à l'assembly dynamique.

dir
String

Nom du répertoire dans lequel l'assembly doit être enregistré. Si dir est null, le répertoire actif est utilisé comme répertoire par défaut.

evidence
Evidence

Preuve fournie pour l'assembly dynamique. La preuve est utilisée non modifiée en tant qu’ensemble de preuves final pour la résolution de stratégie.

requiredPermissions
PermissionSet

Demande d'autorisations requises.

optionalPermissions
PermissionSet

Demande d'autorisations facultatives.

refusedPermissions
PermissionSet

Demande d'autorisations refusées.

Retours

Assembly dynamique avec le nom et les fonctionnalités spécifiés.

Implémente

Attributs

Exceptions

name a la valeur null.

La propriété Name de name a la valeur null.

- ou -

La propriété Name de name commence par un espace blanc ou contient une barre oblique ou une barre oblique inverse.

L’opération est tentée sur un domaine d’application non chargé.

Exemples

L’exemple suivant illustre la méthode et l’événement DefineDynamicAssemblyAssemblyResolve .

Pour que cet exemple de code s’exécute, vous devez fournir le nom complet de l’assembly. Pour plus d’informations sur la façon d’obtenir le nom complet de l’assembly, consultez Noms d’assembly.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
ref class Test
{
public:
   static void InstantiateMyDynamicType( AppDomain^ domain )
   {
      try
      {
         
         // You must supply a valid fully qualified assembly name here.
         domain->CreateInstance( "Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType" );
      }
      catch ( Exception^ e ) 
      {
         Console::WriteLine( e->Message );
      }

   }

   static Assembly^ MyResolveEventHandler( Object^ sender, ResolveEventArgs^ args )
   {
      return DefineDynamicAssembly( dynamic_cast<AppDomain^>(sender) );
   }

   static Assembly^ DefineDynamicAssembly( AppDomain^ domain )
   {
      
      // Build a dynamic assembly using Reflection Emit API.
      AssemblyName^ assemblyName = gcnew AssemblyName;
      assemblyName->Name = "MyDynamicAssembly";
      AssemblyBuilder^ assemblyBuilder = domain->DefineDynamicAssembly( assemblyName, AssemblyBuilderAccess::Run );
      ModuleBuilder^ moduleBuilder = assemblyBuilder->DefineDynamicModule( "MyDynamicModule" );
      TypeBuilder^ typeBuilder = moduleBuilder->DefineType( "MyDynamicType", TypeAttributes::Public );
      ConstructorBuilder^ constructorBuilder = typeBuilder->DefineConstructor( MethodAttributes::Public, CallingConventions::Standard, nullptr );
      ILGenerator^ ilGenerator = constructorBuilder->GetILGenerator();
      ilGenerator->EmitWriteLine( "MyDynamicType instantiated!" );
      ilGenerator->Emit( OpCodes::Ret );
      typeBuilder->CreateType();
      return assemblyBuilder;
   }

};

int main()
{
   AppDomain^ currentDomain = AppDomain::CurrentDomain;
   Test::InstantiateMyDynamicType( currentDomain ); // Failed!
   currentDomain->AssemblyResolve += gcnew ResolveEventHandler( Test::MyResolveEventHandler );
   Test::InstantiateMyDynamicType( currentDomain ); // OK!
}
using System;
using System.Reflection;
using System.Reflection.Emit;

class DefinedDynamicAssemblySnippet {
   public static void Main() {
      AppDomain currentDomain = AppDomain.CurrentDomain;

      InstantiateMyDynamicType(currentDomain);   // Failed!

      currentDomain.AssemblyResolve += new ResolveEventHandler(MyResolveEventHandler);

      InstantiateMyDynamicType(currentDomain);   // OK!
   }

   static void InstantiateMyDynamicType(AppDomain domain) {
      try {
         // You must supply a valid fully qualified assembly name here.
         domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType");
      } catch (Exception e) {
         Console.WriteLine(e.Message);
      }
   }

   static Assembly MyResolveEventHandler(object sender, ResolveEventArgs args) {
      return DefineDynamicAssembly((AppDomain) sender);
   }

   static Assembly DefineDynamicAssembly(AppDomain domain) {
      // Build a dynamic assembly using Reflection Emit API.

      AssemblyName assemblyName = new AssemblyName();
      assemblyName.Name = "MyDynamicAssembly";

      AssemblyBuilder assemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
      ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("MyDynamicModule");
      TypeBuilder typeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public);
      ConstructorBuilder constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, null);
      ILGenerator ilGenerator = constructorBuilder.GetILGenerator();

      ilGenerator.EmitWriteLine("MyDynamicType instantiated!");
      ilGenerator.Emit(OpCodes.Ret);

      typeBuilder.CreateType();

      return assemblyBuilder;
   }
}
open System
open System.Reflection
open System.Reflection.Emit

let instantiateMyDynamicType (domain: AppDomain) =
    try
        // You must supply a valid fully qualified assembly name here.
        domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType")
        |> ignore
    with e ->
        printfn $"{e.Message}"

let defineDynamicAssembly (domain: AppDomain) =
    // Build a dynamic assembly using Reflection Emit API.
    let assemblyName = AssemblyName()
    assemblyName.Name <- "MyDynamicAssembly"

    let assemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run)
    let moduleBuilder = assemblyBuilder.DefineDynamicModule "MyDynamicModule"
    let typeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public)
    let constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, null)
    let ilGenerator = constructorBuilder.GetILGenerator()

    ilGenerator.EmitWriteLine "MyDynamicType instantiated!"
    ilGenerator.Emit OpCodes.Ret

    typeBuilder.CreateType() |> ignore

    assemblyBuilder

let myResolveEventHandler (sender: obj) _ =
    defineDynamicAssembly (sender :?> AppDomain)
    :> Assembly
   
let currentDomain = AppDomain.CurrentDomain

instantiateMyDynamicType currentDomain   // Failed!

currentDomain.add_AssemblyResolve(ResolveEventHandler myResolveEventHandler)

instantiateMyDynamicType currentDomain   // OK!

Imports System.Reflection
Imports System.Reflection.Emit

Module Test
   
   Sub Main()
      Dim currentDomain As AppDomain = AppDomain.CurrentDomain
      
      InstantiateMyDynamicType(currentDomain)   'Failed!
      
      AddHandler currentDomain.AssemblyResolve, AddressOf MyResolveEventHandler
      
      InstantiateMyDynamicType(currentDomain)   'OK!
   End Sub
   
   Sub InstantiateMyDynamicType(domain As AppDomain)
      Try
         ' You must supply a valid fully qualified assembly name here.
         domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType")
      Catch e As Exception
         Console.WriteLine(e.Message)
      End Try
   End Sub
   
   Function MyResolveEventHandler(sender As Object, args As ResolveEventArgs) As System.Reflection.Assembly
      Return DefineDynamicAssembly(DirectCast(sender, AppDomain))
   End Function 'MyResolveEventHandler
   
   Function DefineDynamicAssembly(domain As AppDomain) As System.Reflection.Assembly
      ' Build a dynamic assembly using Reflection Emit API.

      Dim assemblyName As New AssemblyName()
      assemblyName.Name = "MyDynamicAssembly"
      
      Dim assemblyBuilder As AssemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run)
      Dim moduleBuilder As ModuleBuilder = assemblyBuilder.DefineDynamicModule("MyDynamicModule")
      Dim typeBuilder As TypeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public)
      Dim constructorBuilder As ConstructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Nothing)
      Dim ilGenerator As ILGenerator = constructorBuilder.GetILGenerator()
      
      ilGenerator.EmitWriteLine("MyDynamicType instantiated!")
      ilGenerator.Emit(OpCodes.Ret)
      
      typeBuilder.CreateType()
      
      Return assemblyBuilder
   End Function 'DefineDynamicAssembly

End Module 'Test

Remarques

Les demandes d’autorisation spécifiées pour requiredPermissions, optionalPermissionset refusedPermissions ne sont utilisées que si evidence est également fourni ou si l’assembly dynamique est enregistré et rechargé en mémoire.

Notes

Lors du développement de code qui émet des assemblys dynamiques, il est recommandé d’inclure SecurityPermissionFlag.SkipVerification dans refusedPermissions. L’inclusion SkipVerification dans le refusedPermissions paramètre garantit que le MSIL est vérifié. Une limitation de cette technique est qu’elle provoque également la SecurityException levée lorsqu’elle est utilisée avec du code qui demande une confiance totale.

Seuls les appelants entièrement approuvés peuvent fournir leur evidence lors de la définition d’un dynamique Assembly. Le runtime mappe le Evidence via la stratégie de sécurité pour déterminer les autorisations accordées. Les appelants partiellement approuvés doivent fournir une valeur null evidence. Si evidence a la valeur null, le runtime copie les jeux d’autorisations, c’est-à-dire les jeux d’octroi et de refus actuels, de l’appelant Assembly à la dynamique Assembly en cours de définition et marque la stratégie comme résolue.

Si la dynamique Assembly est enregistrée sur le disque, les charges suivantes recevront des subventions en fonction des stratégies associées à l’emplacement où le Assembly a été enregistré.

Cette méthode doit uniquement être utilisée pour définir un assembly dynamique dans le domaine d’application actuel. Pour plus d’informations, consultez la surcharge de Load(AssemblyName) méthode.

S’applique à

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, PermissionSet, PermissionSet, PermissionSet)

Attention

Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.

Définit un assembly dynamique avec le nom, le mode d'accès, le répertoire de stockage et les demandes d'autorisations spécifiés.

public:
 virtual System::Reflection::Emit::AssemblyBuilder ^ DefineDynamicAssembly(System::Reflection::AssemblyName ^ name, System::Reflection::Emit::AssemblyBuilderAccess access, System::String ^ dir, System::Security::PermissionSet ^ requiredPermissions, System::Security::PermissionSet ^ optionalPermissions, System::Security::PermissionSet ^ refusedPermissions);
public System.Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (System.Reflection.AssemblyName name, System.Reflection.Emit.AssemblyBuilderAccess access, string dir, System.Security.PermissionSet requiredPermissions, System.Security.PermissionSet optionalPermissions, System.Security.PermissionSet refusedPermissions);
[System.Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
public System.Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (System.Reflection.AssemblyName name, System.Reflection.Emit.AssemblyBuilderAccess access, string dir, System.Security.PermissionSet requiredPermissions, System.Security.PermissionSet optionalPermissions, System.Security.PermissionSet refusedPermissions);
abstract member DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * string * System.Security.PermissionSet * System.Security.PermissionSet * System.Security.PermissionSet -> System.Reflection.Emit.AssemblyBuilder
override this.DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * string * System.Security.PermissionSet * System.Security.PermissionSet * System.Security.PermissionSet -> System.Reflection.Emit.AssemblyBuilder
[<System.Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")>]
abstract member DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * string * System.Security.PermissionSet * System.Security.PermissionSet * System.Security.PermissionSet -> System.Reflection.Emit.AssemblyBuilder
override this.DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * string * System.Security.PermissionSet * System.Security.PermissionSet * System.Security.PermissionSet -> System.Reflection.Emit.AssemblyBuilder
Public Function DefineDynamicAssembly (name As AssemblyName, access As AssemblyBuilderAccess, dir As String, requiredPermissions As PermissionSet, optionalPermissions As PermissionSet, refusedPermissions As PermissionSet) As AssemblyBuilder

Paramètres

name
AssemblyName

Identité unique de l'assembly dynamique.

access
AssemblyBuilderAccess

Mode d'accès à l'assembly dynamique.

dir
String

Nom du répertoire dans lequel l'assembly doit être enregistré. Si dir est null, le répertoire actif est utilisé comme répertoire par défaut.

requiredPermissions
PermissionSet

Demande d'autorisations requises.

optionalPermissions
PermissionSet

Demande d'autorisations facultatives.

refusedPermissions
PermissionSet

Demande d'autorisations refusées.

Retours

Assembly dynamique avec le nom et les fonctionnalités spécifiés.

Implémente

Attributs

Exceptions

name a la valeur null.

La propriété Name de name a la valeur null.

- ou -

La propriété Name de name commence par un espace blanc ou contient une barre oblique ou une barre oblique inverse.

L’opération est tentée sur un domaine d’application non chargé.

Exemples

L’exemple suivant illustre la méthode et l’événement DefineDynamicAssemblyAssemblyResolve .

Pour que cet exemple de code s’exécute, vous devez fournir le nom complet de l’assembly. Pour plus d’informations sur la façon d’obtenir le nom complet de l’assembly, consultez Noms d’assembly.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
ref class Test
{
public:
   static void InstantiateMyDynamicType( AppDomain^ domain )
   {
      try
      {
         
         // You must supply a valid fully qualified assembly name here.
         domain->CreateInstance( "Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType" );
      }
      catch ( Exception^ e ) 
      {
         Console::WriteLine( e->Message );
      }

   }

   static Assembly^ MyResolveEventHandler( Object^ sender, ResolveEventArgs^ args )
   {
      return DefineDynamicAssembly( dynamic_cast<AppDomain^>(sender) );
   }

   static Assembly^ DefineDynamicAssembly( AppDomain^ domain )
   {
      
      // Build a dynamic assembly using Reflection Emit API.
      AssemblyName^ assemblyName = gcnew AssemblyName;
      assemblyName->Name = "MyDynamicAssembly";
      AssemblyBuilder^ assemblyBuilder = domain->DefineDynamicAssembly( assemblyName, AssemblyBuilderAccess::Run );
      ModuleBuilder^ moduleBuilder = assemblyBuilder->DefineDynamicModule( "MyDynamicModule" );
      TypeBuilder^ typeBuilder = moduleBuilder->DefineType( "MyDynamicType", TypeAttributes::Public );
      ConstructorBuilder^ constructorBuilder = typeBuilder->DefineConstructor( MethodAttributes::Public, CallingConventions::Standard, nullptr );
      ILGenerator^ ilGenerator = constructorBuilder->GetILGenerator();
      ilGenerator->EmitWriteLine( "MyDynamicType instantiated!" );
      ilGenerator->Emit( OpCodes::Ret );
      typeBuilder->CreateType();
      return assemblyBuilder;
   }

};

int main()
{
   AppDomain^ currentDomain = AppDomain::CurrentDomain;
   Test::InstantiateMyDynamicType( currentDomain ); // Failed!
   currentDomain->AssemblyResolve += gcnew ResolveEventHandler( Test::MyResolveEventHandler );
   Test::InstantiateMyDynamicType( currentDomain ); // OK!
}
using System;
using System.Reflection;
using System.Reflection.Emit;

class DefinedDynamicAssemblySnippet {
   public static void Main() {
      AppDomain currentDomain = AppDomain.CurrentDomain;

      InstantiateMyDynamicType(currentDomain);   // Failed!

      currentDomain.AssemblyResolve += new ResolveEventHandler(MyResolveEventHandler);

      InstantiateMyDynamicType(currentDomain);   // OK!
   }

   static void InstantiateMyDynamicType(AppDomain domain) {
      try {
         // You must supply a valid fully qualified assembly name here.
         domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType");
      } catch (Exception e) {
         Console.WriteLine(e.Message);
      }
   }

   static Assembly MyResolveEventHandler(object sender, ResolveEventArgs args) {
      return DefineDynamicAssembly((AppDomain) sender);
   }

   static Assembly DefineDynamicAssembly(AppDomain domain) {
      // Build a dynamic assembly using Reflection Emit API.

      AssemblyName assemblyName = new AssemblyName();
      assemblyName.Name = "MyDynamicAssembly";

      AssemblyBuilder assemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
      ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("MyDynamicModule");
      TypeBuilder typeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public);
      ConstructorBuilder constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, null);
      ILGenerator ilGenerator = constructorBuilder.GetILGenerator();

      ilGenerator.EmitWriteLine("MyDynamicType instantiated!");
      ilGenerator.Emit(OpCodes.Ret);

      typeBuilder.CreateType();

      return assemblyBuilder;
   }
}
open System
open System.Reflection
open System.Reflection.Emit

let instantiateMyDynamicType (domain: AppDomain) =
    try
        // You must supply a valid fully qualified assembly name here.
        domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType")
        |> ignore
    with e ->
        printfn $"{e.Message}"

let defineDynamicAssembly (domain: AppDomain) =
    // Build a dynamic assembly using Reflection Emit API.
    let assemblyName = AssemblyName()
    assemblyName.Name <- "MyDynamicAssembly"

    let assemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run)
    let moduleBuilder = assemblyBuilder.DefineDynamicModule "MyDynamicModule"
    let typeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public)
    let constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, null)
    let ilGenerator = constructorBuilder.GetILGenerator()

    ilGenerator.EmitWriteLine "MyDynamicType instantiated!"
    ilGenerator.Emit OpCodes.Ret

    typeBuilder.CreateType() |> ignore

    assemblyBuilder

let myResolveEventHandler (sender: obj) _ =
    defineDynamicAssembly (sender :?> AppDomain)
    :> Assembly
   
let currentDomain = AppDomain.CurrentDomain

instantiateMyDynamicType currentDomain   // Failed!

currentDomain.add_AssemblyResolve(ResolveEventHandler myResolveEventHandler)

instantiateMyDynamicType currentDomain   // OK!

Imports System.Reflection
Imports System.Reflection.Emit

Module Test
   
   Sub Main()
      Dim currentDomain As AppDomain = AppDomain.CurrentDomain
      
      InstantiateMyDynamicType(currentDomain)   'Failed!
      
      AddHandler currentDomain.AssemblyResolve, AddressOf MyResolveEventHandler
      
      InstantiateMyDynamicType(currentDomain)   'OK!
   End Sub
   
   Sub InstantiateMyDynamicType(domain As AppDomain)
      Try
         ' You must supply a valid fully qualified assembly name here.
         domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType")
      Catch e As Exception
         Console.WriteLine(e.Message)
      End Try
   End Sub
   
   Function MyResolveEventHandler(sender As Object, args As ResolveEventArgs) As System.Reflection.Assembly
      Return DefineDynamicAssembly(DirectCast(sender, AppDomain))
   End Function 'MyResolveEventHandler
   
   Function DefineDynamicAssembly(domain As AppDomain) As System.Reflection.Assembly
      ' Build a dynamic assembly using Reflection Emit API.

      Dim assemblyName As New AssemblyName()
      assemblyName.Name = "MyDynamicAssembly"
      
      Dim assemblyBuilder As AssemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run)
      Dim moduleBuilder As ModuleBuilder = assemblyBuilder.DefineDynamicModule("MyDynamicModule")
      Dim typeBuilder As TypeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public)
      Dim constructorBuilder As ConstructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Nothing)
      Dim ilGenerator As ILGenerator = constructorBuilder.GetILGenerator()
      
      ilGenerator.EmitWriteLine("MyDynamicType instantiated!")
      ilGenerator.Emit(OpCodes.Ret)
      
      typeBuilder.CreateType()
      
      Return assemblyBuilder
   End Function 'DefineDynamicAssembly

End Module 'Test

Remarques

Les demandes d’autorisation spécifiées pour requiredPermissions, optionalPermissionset refusedPermissions ne sont utilisées que si l’assembly dynamique a été enregistré et rechargé en mémoire. Pour spécifier les demandes d’autorisation pour un assembly temporaire qui n’est jamais enregistré sur le disque, utilisez une surcharge de la DefineDynamicAssembly méthode qui spécifie les preuves ainsi que les autorisations demandées et fournissez un Evidence objet.

Notes

Pendant le développement de code qui émet des assemblys dynamiques, il est recommandé d’utiliser une surcharge de la méthode qui spécifie les DefineDynamicAssembly preuves et les autorisations, de fournir la preuve que vous souhaitez que l’assembly dynamique ait et d’inclure SecurityPermissionFlag.SkipVerification dans refusedPermissions. L’inclusion SkipVerification dans le refusedPermissions paramètre garantit que le MSIL est vérifié. Une limitation de cette technique est qu’elle provoque également la SecurityException levée lorsqu’elle est utilisée avec du code qui demande une confiance totale.

Cette méthode doit uniquement être utilisée pour définir un assembly dynamique dans le domaine d’application actuel. Pour plus d’informations, consultez la surcharge de Load(AssemblyName) méthode.

S’applique à

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, Evidence, PermissionSet, PermissionSet, PermissionSet)

Attention

Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.

Définit un assembly dynamique avec le nom, le mode d'accès, la preuve et les demandes d'autorisations spécifiés.

public:
 virtual System::Reflection::Emit::AssemblyBuilder ^ DefineDynamicAssembly(System::Reflection::AssemblyName ^ name, System::Reflection::Emit::AssemblyBuilderAccess access, System::Security::Policy::Evidence ^ evidence, System::Security::PermissionSet ^ requiredPermissions, System::Security::PermissionSet ^ optionalPermissions, System::Security::PermissionSet ^ refusedPermissions);
public System.Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (System.Reflection.AssemblyName name, System.Reflection.Emit.AssemblyBuilderAccess access, System.Security.Policy.Evidence evidence, System.Security.PermissionSet requiredPermissions, System.Security.PermissionSet optionalPermissions, System.Security.PermissionSet refusedPermissions);
[System.Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
public System.Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (System.Reflection.AssemblyName name, System.Reflection.Emit.AssemblyBuilderAccess access, System.Security.Policy.Evidence evidence, System.Security.PermissionSet requiredPermissions, System.Security.PermissionSet optionalPermissions, System.Security.PermissionSet refusedPermissions);
abstract member DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * System.Security.Policy.Evidence * System.Security.PermissionSet * System.Security.PermissionSet * System.Security.PermissionSet -> System.Reflection.Emit.AssemblyBuilder
override this.DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * System.Security.Policy.Evidence * System.Security.PermissionSet * System.Security.PermissionSet * System.Security.PermissionSet -> System.Reflection.Emit.AssemblyBuilder
[<System.Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")>]
abstract member DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * System.Security.Policy.Evidence * System.Security.PermissionSet * System.Security.PermissionSet * System.Security.PermissionSet -> System.Reflection.Emit.AssemblyBuilder
override this.DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * System.Security.Policy.Evidence * System.Security.PermissionSet * System.Security.PermissionSet * System.Security.PermissionSet -> System.Reflection.Emit.AssemblyBuilder
Public Function DefineDynamicAssembly (name As AssemblyName, access As AssemblyBuilderAccess, evidence As Evidence, requiredPermissions As PermissionSet, optionalPermissions As PermissionSet, refusedPermissions As PermissionSet) As AssemblyBuilder

Paramètres

name
AssemblyName

Identité unique de l'assembly dynamique.

access
AssemblyBuilderAccess

Mode d'accès à l'assembly dynamique.

evidence
Evidence

Preuve fournie pour l'assembly dynamique. La preuve est utilisée non modifiée en tant qu’ensemble de preuves final pour la résolution de stratégie.

requiredPermissions
PermissionSet

Demande d'autorisations requises.

optionalPermissions
PermissionSet

Demande d'autorisations facultatives.

refusedPermissions
PermissionSet

Demande d'autorisations refusées.

Retours

Assembly dynamique avec le nom et les fonctionnalités spécifiés.

Implémente

Attributs

Exceptions

name a la valeur null.

La propriété Name de name a la valeur null.

- ou -

La propriété Name de name commence par un espace blanc ou contient une barre oblique ou une barre oblique inverse.

L’opération est tentée sur un domaine d’application non chargé.

Exemples

L’exemple suivant illustre la méthode et l’événement DefineDynamicAssemblyAssemblyResolve .

Pour que cet exemple de code s’exécute, vous devez fournir le nom complet de l’assembly. Pour plus d’informations sur la façon d’obtenir le nom complet de l’assembly, consultez Noms d’assembly.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
ref class Test
{
public:
   static void InstantiateMyDynamicType( AppDomain^ domain )
   {
      try
      {
         
         // You must supply a valid fully qualified assembly name here.
         domain->CreateInstance( "Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType" );
      }
      catch ( Exception^ e ) 
      {
         Console::WriteLine( e->Message );
      }

   }

   static Assembly^ MyResolveEventHandler( Object^ sender, ResolveEventArgs^ args )
   {
      return DefineDynamicAssembly( dynamic_cast<AppDomain^>(sender) );
   }

   static Assembly^ DefineDynamicAssembly( AppDomain^ domain )
   {
      
      // Build a dynamic assembly using Reflection Emit API.
      AssemblyName^ assemblyName = gcnew AssemblyName;
      assemblyName->Name = "MyDynamicAssembly";
      AssemblyBuilder^ assemblyBuilder = domain->DefineDynamicAssembly( assemblyName, AssemblyBuilderAccess::Run );
      ModuleBuilder^ moduleBuilder = assemblyBuilder->DefineDynamicModule( "MyDynamicModule" );
      TypeBuilder^ typeBuilder = moduleBuilder->DefineType( "MyDynamicType", TypeAttributes::Public );
      ConstructorBuilder^ constructorBuilder = typeBuilder->DefineConstructor( MethodAttributes::Public, CallingConventions::Standard, nullptr );
      ILGenerator^ ilGenerator = constructorBuilder->GetILGenerator();
      ilGenerator->EmitWriteLine( "MyDynamicType instantiated!" );
      ilGenerator->Emit( OpCodes::Ret );
      typeBuilder->CreateType();
      return assemblyBuilder;
   }

};

int main()
{
   AppDomain^ currentDomain = AppDomain::CurrentDomain;
   Test::InstantiateMyDynamicType( currentDomain ); // Failed!
   currentDomain->AssemblyResolve += gcnew ResolveEventHandler( Test::MyResolveEventHandler );
   Test::InstantiateMyDynamicType( currentDomain ); // OK!
}
using System;
using System.Reflection;
using System.Reflection.Emit;

class DefinedDynamicAssemblySnippet {
   public static void Main() {
      AppDomain currentDomain = AppDomain.CurrentDomain;

      InstantiateMyDynamicType(currentDomain);   // Failed!

      currentDomain.AssemblyResolve += new ResolveEventHandler(MyResolveEventHandler);

      InstantiateMyDynamicType(currentDomain);   // OK!
   }

   static void InstantiateMyDynamicType(AppDomain domain) {
      try {
         // You must supply a valid fully qualified assembly name here.
         domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType");
      } catch (Exception e) {
         Console.WriteLine(e.Message);
      }
   }

   static Assembly MyResolveEventHandler(object sender, ResolveEventArgs args) {
      return DefineDynamicAssembly((AppDomain) sender);
   }

   static Assembly DefineDynamicAssembly(AppDomain domain) {
      // Build a dynamic assembly using Reflection Emit API.

      AssemblyName assemblyName = new AssemblyName();
      assemblyName.Name = "MyDynamicAssembly";

      AssemblyBuilder assemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
      ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("MyDynamicModule");
      TypeBuilder typeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public);
      ConstructorBuilder constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, null);
      ILGenerator ilGenerator = constructorBuilder.GetILGenerator();

      ilGenerator.EmitWriteLine("MyDynamicType instantiated!");
      ilGenerator.Emit(OpCodes.Ret);

      typeBuilder.CreateType();

      return assemblyBuilder;
   }
}
open System
open System.Reflection
open System.Reflection.Emit

let instantiateMyDynamicType (domain: AppDomain) =
    try
        // You must supply a valid fully qualified assembly name here.
        domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType")
        |> ignore
    with e ->
        printfn $"{e.Message}"

let defineDynamicAssembly (domain: AppDomain) =
    // Build a dynamic assembly using Reflection Emit API.
    let assemblyName = AssemblyName()
    assemblyName.Name <- "MyDynamicAssembly"

    let assemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run)
    let moduleBuilder = assemblyBuilder.DefineDynamicModule "MyDynamicModule"
    let typeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public)
    let constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, null)
    let ilGenerator = constructorBuilder.GetILGenerator()

    ilGenerator.EmitWriteLine "MyDynamicType instantiated!"
    ilGenerator.Emit OpCodes.Ret

    typeBuilder.CreateType() |> ignore

    assemblyBuilder

let myResolveEventHandler (sender: obj) _ =
    defineDynamicAssembly (sender :?> AppDomain)
    :> Assembly
   
let currentDomain = AppDomain.CurrentDomain

instantiateMyDynamicType currentDomain   // Failed!

currentDomain.add_AssemblyResolve(ResolveEventHandler myResolveEventHandler)

instantiateMyDynamicType currentDomain   // OK!

Imports System.Reflection
Imports System.Reflection.Emit

Module Test
   
   Sub Main()
      Dim currentDomain As AppDomain = AppDomain.CurrentDomain
      
      InstantiateMyDynamicType(currentDomain)   'Failed!
      
      AddHandler currentDomain.AssemblyResolve, AddressOf MyResolveEventHandler
      
      InstantiateMyDynamicType(currentDomain)   'OK!
   End Sub
   
   Sub InstantiateMyDynamicType(domain As AppDomain)
      Try
         ' You must supply a valid fully qualified assembly name here.
         domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType")
      Catch e As Exception
         Console.WriteLine(e.Message)
      End Try
   End Sub
   
   Function MyResolveEventHandler(sender As Object, args As ResolveEventArgs) As System.Reflection.Assembly
      Return DefineDynamicAssembly(DirectCast(sender, AppDomain))
   End Function 'MyResolveEventHandler
   
   Function DefineDynamicAssembly(domain As AppDomain) As System.Reflection.Assembly
      ' Build a dynamic assembly using Reflection Emit API.

      Dim assemblyName As New AssemblyName()
      assemblyName.Name = "MyDynamicAssembly"
      
      Dim assemblyBuilder As AssemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run)
      Dim moduleBuilder As ModuleBuilder = assemblyBuilder.DefineDynamicModule("MyDynamicModule")
      Dim typeBuilder As TypeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public)
      Dim constructorBuilder As ConstructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Nothing)
      Dim ilGenerator As ILGenerator = constructorBuilder.GetILGenerator()
      
      ilGenerator.EmitWriteLine("MyDynamicType instantiated!")
      ilGenerator.Emit(OpCodes.Ret)
      
      typeBuilder.CreateType()
      
      Return assemblyBuilder
   End Function 'DefineDynamicAssembly

End Module 'Test

Remarques

Les demandes d’autorisation spécifiées pour requiredPermissions, optionalPermissionset refusedPermissions ne sont utilisées que si evidence est également fourni ou si l’assembly dynamique est enregistré et rechargé en mémoire.

Notes

Lors du développement de code qui émet des assemblys dynamiques, il est recommandé d’inclure SecurityPermissionFlag.SkipVerification dans refusedPermissions. L’inclusion SkipVerification dans le refusedPermissions paramètre garantit que le MSIL est vérifié. Une limitation de cette technique est qu’elle provoque également la SecurityException levée lorsqu’elle est utilisée avec du code qui demande une confiance totale.

Seuls les appelants entièrement approuvés peuvent fournir leur evidence lors de la définition d’un dynamique Assembly. Le runtime mappe le Evidence via la stratégie de sécurité pour déterminer les autorisations accordées. Les appelants partiellement approuvés doivent fournir une valeur null evidence. Si evidence a la valeur null, le runtime copie les jeux d’autorisations, c’est-à-dire les jeux d’octroi et de refus actuels, de l’appelant Assembly à la dynamique Assembly en cours de définition et marque la stratégie comme résolue.

Si la dynamique Assembly est enregistrée sur le disque, les charges suivantes recevront des subventions en fonction des stratégies associées à l’emplacement où le Assembly a été enregistré.

Cette méthode doit uniquement être utilisée pour définir un assembly dynamique dans le domaine d’application actuel. Pour plus d’informations, consultez la surcharge de Load(AssemblyName) méthode.

S’applique à

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Boolean, IEnumerable<CustomAttributeBuilder>)

Définit un assembly dynamique avec le nom, le mode d'accès, le répertoire de stockage et l'option de synchronisation spécifiés.

public:
 System::Reflection::Emit::AssemblyBuilder ^ DefineDynamicAssembly(System::Reflection::AssemblyName ^ name, System::Reflection::Emit::AssemblyBuilderAccess access, System::String ^ dir, bool isSynchronized, System::Collections::Generic::IEnumerable<System::Reflection::Emit::CustomAttributeBuilder ^> ^ assemblyAttributes);
public System.Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (System.Reflection.AssemblyName name, System.Reflection.Emit.AssemblyBuilderAccess access, string dir, bool isSynchronized, System.Collections.Generic.IEnumerable<System.Reflection.Emit.CustomAttributeBuilder> assemblyAttributes);
member this.DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * string * bool * seq<System.Reflection.Emit.CustomAttributeBuilder> -> System.Reflection.Emit.AssemblyBuilder
Public Function DefineDynamicAssembly (name As AssemblyName, access As AssemblyBuilderAccess, dir As String, isSynchronized As Boolean, assemblyAttributes As IEnumerable(Of CustomAttributeBuilder)) As AssemblyBuilder

Paramètres

name
AssemblyName

Identité unique de l'assembly dynamique.

access
AssemblyBuilderAccess

Mode d'accès à l'assembly dynamique.

dir
String

Nom du répertoire dans lequel l'assembly dynamique doit être enregistré. Si dir est null, le répertoire actif est utilisé.

isSynchronized
Boolean

true pour synchroniser la création de modules, de types et de membres dans l'assembly dynamique ; sinon, false.

assemblyAttributes
IEnumerable<CustomAttributeBuilder>

Une liste enumérable d'attributs à appliquer à l'assembly, ou null s'il n'y a pas d'attributs.

Retours

Assembly dynamique avec le nom et les fonctionnalités spécifiés.

Exceptions

name a la valeur null.

La propriété Name de name a la valeur null.

- ou -

La propriété Name de name commence par un espace blanc ou bien contient une barre oblique ou une barre oblique inverse.

L’opération est tentée sur un domaine d’application non chargé.

Remarques

Utilisez cette surcharge de méthode pour spécifier des attributs qui ne fonctionnent pas correctement, sauf s’ils sont appliqués lors de la création d’un assembly dynamique. Par exemple, les attributs de sécurité tels que SecurityTransparentAttribute et SecurityCriticalAttribute ne fonctionnent pas correctement s’ils sont ajoutés après la création d’un assembly dynamique.

Si isSynchronized a la valeur true, les méthodes suivantes du résultat AssemblyBuilder seront synchronisées : DefineDynamicModule, DefineResource, AddResourceFile, GetDynamicModule, , SetEntryPointet Save. Si deux de ces méthodes sont appelées sur des threads différents, l’une est bloquée jusqu’à ce que l’autre soit terminée.

Voir aussi

S’applique à

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, PermissionSet, PermissionSet, PermissionSet)

Attention

Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.

Définit un assembly dynamique avec le nom, le mode d'accès et les demandes d'autorisations spécifiés.

public:
 virtual System::Reflection::Emit::AssemblyBuilder ^ DefineDynamicAssembly(System::Reflection::AssemblyName ^ name, System::Reflection::Emit::AssemblyBuilderAccess access, System::Security::PermissionSet ^ requiredPermissions, System::Security::PermissionSet ^ optionalPermissions, System::Security::PermissionSet ^ refusedPermissions);
public System.Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (System.Reflection.AssemblyName name, System.Reflection.Emit.AssemblyBuilderAccess access, System.Security.PermissionSet requiredPermissions, System.Security.PermissionSet optionalPermissions, System.Security.PermissionSet refusedPermissions);
[System.Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default.  See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
public System.Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (System.Reflection.AssemblyName name, System.Reflection.Emit.AssemblyBuilderAccess access, System.Security.PermissionSet requiredPermissions, System.Security.PermissionSet optionalPermissions, System.Security.PermissionSet refusedPermissions);
abstract member DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * System.Security.PermissionSet * System.Security.PermissionSet * System.Security.PermissionSet -> System.Reflection.Emit.AssemblyBuilder
override this.DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * System.Security.PermissionSet * System.Security.PermissionSet * System.Security.PermissionSet -> System.Reflection.Emit.AssemblyBuilder
[<System.Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default.  See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")>]
abstract member DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * System.Security.PermissionSet * System.Security.PermissionSet * System.Security.PermissionSet -> System.Reflection.Emit.AssemblyBuilder
override this.DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * System.Security.PermissionSet * System.Security.PermissionSet * System.Security.PermissionSet -> System.Reflection.Emit.AssemblyBuilder
Public Function DefineDynamicAssembly (name As AssemblyName, access As AssemblyBuilderAccess, requiredPermissions As PermissionSet, optionalPermissions As PermissionSet, refusedPermissions As PermissionSet) As AssemblyBuilder

Paramètres

name
AssemblyName

Identité unique de l'assembly dynamique.

access
AssemblyBuilderAccess

Mode d'accès à l'assembly dynamique.

requiredPermissions
PermissionSet

Demande d'autorisations requises.

optionalPermissions
PermissionSet

Demande d'autorisations facultatives.

refusedPermissions
PermissionSet

Demande d'autorisations refusées.

Retours

Assembly dynamique avec le nom et les fonctionnalités spécifiés.

Implémente

Attributs

Exceptions

name a la valeur null.

La propriété Name de name a la valeur null.

- ou -

La propriété Name de name commence par un espace blanc ou contient une barre oblique ou une barre oblique inverse.

L’opération est tentée sur un domaine d’application non chargé.

Exemples

L’exemple suivant illustre la méthode et l’événement DefineDynamicAssemblyAssemblyResolve .

Pour que cet exemple de code s’exécute, vous devez fournir le nom complet de l’assembly. Pour plus d’informations sur la façon d’obtenir le nom complet de l’assembly, consultez Noms d’assembly.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
ref class Test
{
public:
   static void InstantiateMyDynamicType( AppDomain^ domain )
   {
      try
      {
         
         // You must supply a valid fully qualified assembly name here.
         domain->CreateInstance( "Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType" );
      }
      catch ( Exception^ e ) 
      {
         Console::WriteLine( e->Message );
      }

   }

   static Assembly^ MyResolveEventHandler( Object^ sender, ResolveEventArgs^ args )
   {
      return DefineDynamicAssembly( dynamic_cast<AppDomain^>(sender) );
   }

   static Assembly^ DefineDynamicAssembly( AppDomain^ domain )
   {
      
      // Build a dynamic assembly using Reflection Emit API.
      AssemblyName^ assemblyName = gcnew AssemblyName;
      assemblyName->Name = "MyDynamicAssembly";
      AssemblyBuilder^ assemblyBuilder = domain->DefineDynamicAssembly( assemblyName, AssemblyBuilderAccess::Run );
      ModuleBuilder^ moduleBuilder = assemblyBuilder->DefineDynamicModule( "MyDynamicModule" );
      TypeBuilder^ typeBuilder = moduleBuilder->DefineType( "MyDynamicType", TypeAttributes::Public );
      ConstructorBuilder^ constructorBuilder = typeBuilder->DefineConstructor( MethodAttributes::Public, CallingConventions::Standard, nullptr );
      ILGenerator^ ilGenerator = constructorBuilder->GetILGenerator();
      ilGenerator->EmitWriteLine( "MyDynamicType instantiated!" );
      ilGenerator->Emit( OpCodes::Ret );
      typeBuilder->CreateType();
      return assemblyBuilder;
   }

};

int main()
{
   AppDomain^ currentDomain = AppDomain::CurrentDomain;
   Test::InstantiateMyDynamicType( currentDomain ); // Failed!
   currentDomain->AssemblyResolve += gcnew ResolveEventHandler( Test::MyResolveEventHandler );
   Test::InstantiateMyDynamicType( currentDomain ); // OK!
}
using System;
using System.Reflection;
using System.Reflection.Emit;

class DefinedDynamicAssemblySnippet {
   public static void Main() {
      AppDomain currentDomain = AppDomain.CurrentDomain;

      InstantiateMyDynamicType(currentDomain);   // Failed!

      currentDomain.AssemblyResolve += new ResolveEventHandler(MyResolveEventHandler);

      InstantiateMyDynamicType(currentDomain);   // OK!
   }

   static void InstantiateMyDynamicType(AppDomain domain) {
      try {
         // You must supply a valid fully qualified assembly name here.
         domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType");
      } catch (Exception e) {
         Console.WriteLine(e.Message);
      }
   }

   static Assembly MyResolveEventHandler(object sender, ResolveEventArgs args) {
      return DefineDynamicAssembly((AppDomain) sender);
   }

   static Assembly DefineDynamicAssembly(AppDomain domain) {
      // Build a dynamic assembly using Reflection Emit API.

      AssemblyName assemblyName = new AssemblyName();
      assemblyName.Name = "MyDynamicAssembly";

      AssemblyBuilder assemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
      ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("MyDynamicModule");
      TypeBuilder typeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public);
      ConstructorBuilder constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, null);
      ILGenerator ilGenerator = constructorBuilder.GetILGenerator();

      ilGenerator.EmitWriteLine("MyDynamicType instantiated!");
      ilGenerator.Emit(OpCodes.Ret);

      typeBuilder.CreateType();

      return assemblyBuilder;
   }
}
open System
open System.Reflection
open System.Reflection.Emit

let instantiateMyDynamicType (domain: AppDomain) =
    try
        // You must supply a valid fully qualified assembly name here.
        domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType")
        |> ignore
    with e ->
        printfn $"{e.Message}"

let defineDynamicAssembly (domain: AppDomain) =
    // Build a dynamic assembly using Reflection Emit API.
    let assemblyName = AssemblyName()
    assemblyName.Name <- "MyDynamicAssembly"

    let assemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run)
    let moduleBuilder = assemblyBuilder.DefineDynamicModule "MyDynamicModule"
    let typeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public)
    let constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, null)
    let ilGenerator = constructorBuilder.GetILGenerator()

    ilGenerator.EmitWriteLine "MyDynamicType instantiated!"
    ilGenerator.Emit OpCodes.Ret

    typeBuilder.CreateType() |> ignore

    assemblyBuilder

let myResolveEventHandler (sender: obj) _ =
    defineDynamicAssembly (sender :?> AppDomain)
    :> Assembly
   
let currentDomain = AppDomain.CurrentDomain

instantiateMyDynamicType currentDomain   // Failed!

currentDomain.add_AssemblyResolve(ResolveEventHandler myResolveEventHandler)

instantiateMyDynamicType currentDomain   // OK!

Imports System.Reflection
Imports System.Reflection.Emit

Module Test
   
   Sub Main()
      Dim currentDomain As AppDomain = AppDomain.CurrentDomain
      
      InstantiateMyDynamicType(currentDomain)   'Failed!
      
      AddHandler currentDomain.AssemblyResolve, AddressOf MyResolveEventHandler
      
      InstantiateMyDynamicType(currentDomain)   'OK!
   End Sub
   
   Sub InstantiateMyDynamicType(domain As AppDomain)
      Try
         ' You must supply a valid fully qualified assembly name here.
         domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType")
      Catch e As Exception
         Console.WriteLine(e.Message)
      End Try
   End Sub
   
   Function MyResolveEventHandler(sender As Object, args As ResolveEventArgs) As System.Reflection.Assembly
      Return DefineDynamicAssembly(DirectCast(sender, AppDomain))
   End Function 'MyResolveEventHandler
   
   Function DefineDynamicAssembly(domain As AppDomain) As System.Reflection.Assembly
      ' Build a dynamic assembly using Reflection Emit API.

      Dim assemblyName As New AssemblyName()
      assemblyName.Name = "MyDynamicAssembly"
      
      Dim assemblyBuilder As AssemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run)
      Dim moduleBuilder As ModuleBuilder = assemblyBuilder.DefineDynamicModule("MyDynamicModule")
      Dim typeBuilder As TypeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public)
      Dim constructorBuilder As ConstructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Nothing)
      Dim ilGenerator As ILGenerator = constructorBuilder.GetILGenerator()
      
      ilGenerator.EmitWriteLine("MyDynamicType instantiated!")
      ilGenerator.Emit(OpCodes.Ret)
      
      typeBuilder.CreateType()
      
      Return assemblyBuilder
   End Function 'DefineDynamicAssembly

End Module 'Test

Remarques

Les demandes d’autorisation spécifiées pour requiredPermissions, optionalPermissionset refusedPermissions ne sont pas utilisées, sauf si l’assembly dynamique a été enregistré et rechargé en mémoire. Pour spécifier des demandes d’autorisation pour un assembly temporaire qui n’est jamais enregistré sur le disque, utilisez une surcharge de la DefineDynamicAssembly méthode qui spécifie des preuves ainsi que des autorisations demandées, et fournissez un Evidence objet.

Notes

Pendant le développement du code qui émet des assemblys dynamiques, il est recommandé d’utiliser une surcharge de la DefineDynamicAssembly méthode qui spécifie des preuves et des autorisations, de fournir la preuve que l’assembly dynamique doit avoir et d’inclure SecurityPermissionFlag.SkipVerification dans refusedPermissions. Le fait d’inclure SkipVerification dans le refusedPermissions paramètre garantit que le MSIL est vérifié. Une limitation de cette technique est qu’elle entraîne SecurityException également la levée lorsqu’elle est utilisée avec du code qui exige une confiance totale.

Cette méthode doit uniquement être utilisée pour définir un assembly dynamique dans le domaine d’application actuel. Pour plus d’informations, consultez la surcharge de méthode Load(AssemblyName) .

S’applique à

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String, Evidence)

Attention

Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of DefineDynamicAssembly which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkId=155570 for more information.

Définit un assembly dynamique avec le nom, le mode d'accès, le répertoire de stockage et la preuve spécifiés.

public:
 virtual System::Reflection::Emit::AssemblyBuilder ^ DefineDynamicAssembly(System::Reflection::AssemblyName ^ name, System::Reflection::Emit::AssemblyBuilderAccess access, System::String ^ dir, System::Security::Policy::Evidence ^ evidence);
public System.Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (System.Reflection.AssemblyName name, System.Reflection.Emit.AssemblyBuilderAccess access, string dir, System.Security.Policy.Evidence evidence);
[System.Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of DefineDynamicAssembly which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkId=155570 for more information.")]
public System.Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (System.Reflection.AssemblyName name, System.Reflection.Emit.AssemblyBuilderAccess access, string dir, System.Security.Policy.Evidence evidence);
abstract member DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * string * System.Security.Policy.Evidence -> System.Reflection.Emit.AssemblyBuilder
override this.DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * string * System.Security.Policy.Evidence -> System.Reflection.Emit.AssemblyBuilder
[<System.Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of DefineDynamicAssembly which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkId=155570 for more information.")>]
abstract member DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * string * System.Security.Policy.Evidence -> System.Reflection.Emit.AssemblyBuilder
override this.DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * string * System.Security.Policy.Evidence -> System.Reflection.Emit.AssemblyBuilder
Public Function DefineDynamicAssembly (name As AssemblyName, access As AssemblyBuilderAccess, dir As String, evidence As Evidence) As AssemblyBuilder

Paramètres

name
AssemblyName

Identité unique de l'assembly dynamique.

access
AssemblyBuilderAccess

Mode d'accès à l'assembly dynamique.

dir
String

Nom du répertoire dans lequel l'assembly doit être enregistré. Si dir est null, le répertoire actif est utilisé comme répertoire par défaut.

evidence
Evidence

Preuve fournie pour l'assembly dynamique. La preuve est utilisée non modifiée en tant qu’ensemble de preuves final pour la résolution de stratégie.

Retours

Assembly dynamique avec le nom et les fonctionnalités spécifiés.

Implémente

Attributs

Exceptions

name a la valeur null.

La propriété Name de name a la valeur null.

- ou -

La propriété Name de name commence par un espace blanc ou contient une barre oblique ou une barre oblique inverse.

L’opération est tentée sur un domaine d’application non chargé.

Exemples

L’exemple suivant illustre la méthode et AssemblyResolve l’événement DefineDynamicAssembly .

Pour que cet exemple de code s’exécute, vous devez fournir le nom complet de l’assembly. Pour plus d’informations sur la façon d’obtenir le nom complet de l’assembly, consultez Noms d’assembly.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
ref class Test
{
public:
   static void InstantiateMyDynamicType( AppDomain^ domain )
   {
      try
      {
         
         // You must supply a valid fully qualified assembly name here.
         domain->CreateInstance( "Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType" );
      }
      catch ( Exception^ e ) 
      {
         Console::WriteLine( e->Message );
      }

   }

   static Assembly^ MyResolveEventHandler( Object^ sender, ResolveEventArgs^ args )
   {
      return DefineDynamicAssembly( dynamic_cast<AppDomain^>(sender) );
   }

   static Assembly^ DefineDynamicAssembly( AppDomain^ domain )
   {
      
      // Build a dynamic assembly using Reflection Emit API.
      AssemblyName^ assemblyName = gcnew AssemblyName;
      assemblyName->Name = "MyDynamicAssembly";
      AssemblyBuilder^ assemblyBuilder = domain->DefineDynamicAssembly( assemblyName, AssemblyBuilderAccess::Run );
      ModuleBuilder^ moduleBuilder = assemblyBuilder->DefineDynamicModule( "MyDynamicModule" );
      TypeBuilder^ typeBuilder = moduleBuilder->DefineType( "MyDynamicType", TypeAttributes::Public );
      ConstructorBuilder^ constructorBuilder = typeBuilder->DefineConstructor( MethodAttributes::Public, CallingConventions::Standard, nullptr );
      ILGenerator^ ilGenerator = constructorBuilder->GetILGenerator();
      ilGenerator->EmitWriteLine( "MyDynamicType instantiated!" );
      ilGenerator->Emit( OpCodes::Ret );
      typeBuilder->CreateType();
      return assemblyBuilder;
   }

};

int main()
{
   AppDomain^ currentDomain = AppDomain::CurrentDomain;
   Test::InstantiateMyDynamicType( currentDomain ); // Failed!
   currentDomain->AssemblyResolve += gcnew ResolveEventHandler( Test::MyResolveEventHandler );
   Test::InstantiateMyDynamicType( currentDomain ); // OK!
}
using System;
using System.Reflection;
using System.Reflection.Emit;

class DefinedDynamicAssemblySnippet {
   public static void Main() {
      AppDomain currentDomain = AppDomain.CurrentDomain;

      InstantiateMyDynamicType(currentDomain);   // Failed!

      currentDomain.AssemblyResolve += new ResolveEventHandler(MyResolveEventHandler);

      InstantiateMyDynamicType(currentDomain);   // OK!
   }

   static void InstantiateMyDynamicType(AppDomain domain) {
      try {
         // You must supply a valid fully qualified assembly name here.
         domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType");
      } catch (Exception e) {
         Console.WriteLine(e.Message);
      }
   }

   static Assembly MyResolveEventHandler(object sender, ResolveEventArgs args) {
      return DefineDynamicAssembly((AppDomain) sender);
   }

   static Assembly DefineDynamicAssembly(AppDomain domain) {
      // Build a dynamic assembly using Reflection Emit API.

      AssemblyName assemblyName = new AssemblyName();
      assemblyName.Name = "MyDynamicAssembly";

      AssemblyBuilder assemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
      ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("MyDynamicModule");
      TypeBuilder typeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public);
      ConstructorBuilder constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, null);
      ILGenerator ilGenerator = constructorBuilder.GetILGenerator();

      ilGenerator.EmitWriteLine("MyDynamicType instantiated!");
      ilGenerator.Emit(OpCodes.Ret);

      typeBuilder.CreateType();

      return assemblyBuilder;
   }
}
open System
open System.Reflection
open System.Reflection.Emit

let instantiateMyDynamicType (domain: AppDomain) =
    try
        // You must supply a valid fully qualified assembly name here.
        domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType")
        |> ignore
    with e ->
        printfn $"{e.Message}"

let defineDynamicAssembly (domain: AppDomain) =
    // Build a dynamic assembly using Reflection Emit API.
    let assemblyName = AssemblyName()
    assemblyName.Name <- "MyDynamicAssembly"

    let assemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run)
    let moduleBuilder = assemblyBuilder.DefineDynamicModule "MyDynamicModule"
    let typeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public)
    let constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, null)
    let ilGenerator = constructorBuilder.GetILGenerator()

    ilGenerator.EmitWriteLine "MyDynamicType instantiated!"
    ilGenerator.Emit OpCodes.Ret

    typeBuilder.CreateType() |> ignore

    assemblyBuilder

let myResolveEventHandler (sender: obj) _ =
    defineDynamicAssembly (sender :?> AppDomain)
    :> Assembly
   
let currentDomain = AppDomain.CurrentDomain

instantiateMyDynamicType currentDomain   // Failed!

currentDomain.add_AssemblyResolve(ResolveEventHandler myResolveEventHandler)

instantiateMyDynamicType currentDomain   // OK!

Imports System.Reflection
Imports System.Reflection.Emit

Module Test
   
   Sub Main()
      Dim currentDomain As AppDomain = AppDomain.CurrentDomain
      
      InstantiateMyDynamicType(currentDomain)   'Failed!
      
      AddHandler currentDomain.AssemblyResolve, AddressOf MyResolveEventHandler
      
      InstantiateMyDynamicType(currentDomain)   'OK!
   End Sub
   
   Sub InstantiateMyDynamicType(domain As AppDomain)
      Try
         ' You must supply a valid fully qualified assembly name here.
         domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType")
      Catch e As Exception
         Console.WriteLine(e.Message)
      End Try
   End Sub
   
   Function MyResolveEventHandler(sender As Object, args As ResolveEventArgs) As System.Reflection.Assembly
      Return DefineDynamicAssembly(DirectCast(sender, AppDomain))
   End Function 'MyResolveEventHandler
   
   Function DefineDynamicAssembly(domain As AppDomain) As System.Reflection.Assembly
      ' Build a dynamic assembly using Reflection Emit API.

      Dim assemblyName As New AssemblyName()
      assemblyName.Name = "MyDynamicAssembly"
      
      Dim assemblyBuilder As AssemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run)
      Dim moduleBuilder As ModuleBuilder = assemblyBuilder.DefineDynamicModule("MyDynamicModule")
      Dim typeBuilder As TypeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public)
      Dim constructorBuilder As ConstructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Nothing)
      Dim ilGenerator As ILGenerator = constructorBuilder.GetILGenerator()
      
      ilGenerator.EmitWriteLine("MyDynamicType instantiated!")
      ilGenerator.Emit(OpCodes.Ret)
      
      typeBuilder.CreateType()
      
      Return assemblyBuilder
   End Function 'DefineDynamicAssembly

End Module 'Test

Remarques

Seuls les appelants entièrement approuvés peuvent fournir leur evidence lors de la définition d’un .Assembly Le runtime mappe le Evidence via la stratégie de sécurité pour déterminer les autorisations accordées. Les appelants partiellement approuvés doivent fournir une valeur null evidence. Si evidence a la valeur null, le runtime copie les jeux d’autorisations, c’est-à-dire les jeux d’octroi et de refus actuels, de l’appelant Assembly à la dynamique Assembly en cours de définition et marque la stratégie comme résolue.

Si la dynamique Assembly est enregistrée sur le disque, les charges suivantes obtiennent des allocations basées sur les stratégies associées à l’emplacement où Assembly a été enregistré.

Cette méthode doit uniquement être utilisée pour définir un assembly dynamique dans le domaine d’application actuel. Pour plus d’informations, consultez la surcharge de Load(AssemblyName) méthode.

Notes

Pendant le développement du code qui émet des assemblys dynamiques, il est recommandé d’utiliser une surcharge de la DefineDynamicAssembly méthode qui spécifie des preuves et des autorisations, de fournir la preuve que l’assembly dynamique doit avoir et d’inclure SecurityPermissionFlag.SkipVerification dans refusedPermissions. Le fait d’inclure SkipVerification dans le refusedPermissions paramètre garantit que le MSIL est vérifié. Une limitation de cette technique est qu’elle entraîne SecurityException également la levée lorsqu’elle est utilisée avec du code qui exige une confiance totale.

S’applique à

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, IEnumerable<CustomAttributeBuilder>, SecurityContextSource)

Définit un assembly dynamique avec le nom, le mode d'accès et les attributs personnalisés spécifiés, à l'aide de la source indiquée pour son contexte de sécurité.

public:
 System::Reflection::Emit::AssemblyBuilder ^ DefineDynamicAssembly(System::Reflection::AssemblyName ^ name, System::Reflection::Emit::AssemblyBuilderAccess access, System::Collections::Generic::IEnumerable<System::Reflection::Emit::CustomAttributeBuilder ^> ^ assemblyAttributes, System::Security::SecurityContextSource securityContextSource);
public System.Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (System.Reflection.AssemblyName name, System.Reflection.Emit.AssemblyBuilderAccess access, System.Collections.Generic.IEnumerable<System.Reflection.Emit.CustomAttributeBuilder> assemblyAttributes, System.Security.SecurityContextSource securityContextSource);
member this.DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * seq<System.Reflection.Emit.CustomAttributeBuilder> * System.Security.SecurityContextSource -> System.Reflection.Emit.AssemblyBuilder
Public Function DefineDynamicAssembly (name As AssemblyName, access As AssemblyBuilderAccess, assemblyAttributes As IEnumerable(Of CustomAttributeBuilder), securityContextSource As SecurityContextSource) As AssemblyBuilder

Paramètres

name
AssemblyName

Identité unique de l'assembly dynamique.

access
AssemblyBuilderAccess

Mode d'accès de l'assembly dynamique.

assemblyAttributes
IEnumerable<CustomAttributeBuilder>

Une liste enumérable d'attributs à appliquer à l'assembly, ou null s'il n'y a pas d'attributs.

securityContextSource
SecurityContextSource

Source du contexte de sécurité.

Retours

Assembly dynamique avec le nom et les fonctionnalités spécifiés.

Exceptions

name a la valeur null.

La propriété Name de name a la valeur null.

- ou -

La propriété Name de name commence par un espace blanc ou bien contient une barre oblique ou une barre oblique inverse.

L’opération est tentée sur un domaine d’application non chargé.

La valeur de securityContextSource ne correspondait pas à une des valeurs d'énumération.

Remarques

Utilisez cette surcharge de méthode pour spécifier des attributs qui ne fonctionnent pas correctement, sauf s’ils sont appliqués lors de la création d’un assembly dynamique. Par exemple, les attributs de sécurité tels que SecurityTransparentAttribute et SecurityCriticalAttribute ne fonctionnent pas correctement s’ils sont ajoutés après la création d’un assembly dynamique.

Cette méthode doit être utilisée uniquement pour définir un assembly dynamique dans le domaine d’application actuel. Pour plus d’informations sur cette restriction, consultez la surcharge de méthode Load(AssemblyName) .

S’applique à

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, String)

Définit un assembly dynamique avec le nom, le mode d'accès et le répertoire de stockage spécifiés.

public:
 virtual System::Reflection::Emit::AssemblyBuilder ^ DefineDynamicAssembly(System::Reflection::AssemblyName ^ name, System::Reflection::Emit::AssemblyBuilderAccess access, System::String ^ dir);
public System.Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (System.Reflection.AssemblyName name, System.Reflection.Emit.AssemblyBuilderAccess access, string dir);
abstract member DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * string -> System.Reflection.Emit.AssemblyBuilder
override this.DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * string -> System.Reflection.Emit.AssemblyBuilder
Public Function DefineDynamicAssembly (name As AssemblyName, access As AssemblyBuilderAccess, dir As String) As AssemblyBuilder

Paramètres

name
AssemblyName

Identité unique de l'assembly dynamique.

access
AssemblyBuilderAccess

Mode d'accès à l'assembly dynamique.

dir
String

Nom du répertoire dans lequel l'assembly doit être enregistré. Si dir est null, le répertoire actif est utilisé comme répertoire par défaut.

Retours

Assembly dynamique avec le nom et les fonctionnalités spécifiés.

Implémente

Exceptions

name a la valeur null.

La propriété Name de name a la valeur null.

- ou -

La propriété Name de name commence par un espace blanc ou contient une barre oblique ou une barre oblique inverse.

L’opération est tentée sur un domaine d’application non chargé.

Exemples

L’exemple suivant illustre la méthode et AssemblyResolve l’événement DefineDynamicAssembly .

Pour que cet exemple de code s’exécute, vous devez fournir le nom complet de l’assembly. Pour plus d’informations sur la façon d’obtenir le nom complet de l’assembly, consultez Noms d’assembly.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
ref class Test
{
public:
   static void InstantiateMyDynamicType( AppDomain^ domain )
   {
      try
      {
         
         // You must supply a valid fully qualified assembly name here.
         domain->CreateInstance( "Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType" );
      }
      catch ( Exception^ e ) 
      {
         Console::WriteLine( e->Message );
      }

   }

   static Assembly^ MyResolveEventHandler( Object^ sender, ResolveEventArgs^ args )
   {
      return DefineDynamicAssembly( dynamic_cast<AppDomain^>(sender) );
   }

   static Assembly^ DefineDynamicAssembly( AppDomain^ domain )
   {
      
      // Build a dynamic assembly using Reflection Emit API.
      AssemblyName^ assemblyName = gcnew AssemblyName;
      assemblyName->Name = "MyDynamicAssembly";
      AssemblyBuilder^ assemblyBuilder = domain->DefineDynamicAssembly( assemblyName, AssemblyBuilderAccess::Run );
      ModuleBuilder^ moduleBuilder = assemblyBuilder->DefineDynamicModule( "MyDynamicModule" );
      TypeBuilder^ typeBuilder = moduleBuilder->DefineType( "MyDynamicType", TypeAttributes::Public );
      ConstructorBuilder^ constructorBuilder = typeBuilder->DefineConstructor( MethodAttributes::Public, CallingConventions::Standard, nullptr );
      ILGenerator^ ilGenerator = constructorBuilder->GetILGenerator();
      ilGenerator->EmitWriteLine( "MyDynamicType instantiated!" );
      ilGenerator->Emit( OpCodes::Ret );
      typeBuilder->CreateType();
      return assemblyBuilder;
   }

};

int main()
{
   AppDomain^ currentDomain = AppDomain::CurrentDomain;
   Test::InstantiateMyDynamicType( currentDomain ); // Failed!
   currentDomain->AssemblyResolve += gcnew ResolveEventHandler( Test::MyResolveEventHandler );
   Test::InstantiateMyDynamicType( currentDomain ); // OK!
}
using System;
using System.Reflection;
using System.Reflection.Emit;

class DefinedDynamicAssemblySnippet {
   public static void Main() {
      AppDomain currentDomain = AppDomain.CurrentDomain;

      InstantiateMyDynamicType(currentDomain);   // Failed!

      currentDomain.AssemblyResolve += new ResolveEventHandler(MyResolveEventHandler);

      InstantiateMyDynamicType(currentDomain);   // OK!
   }

   static void InstantiateMyDynamicType(AppDomain domain) {
      try {
         // You must supply a valid fully qualified assembly name here.
         domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType");
      } catch (Exception e) {
         Console.WriteLine(e.Message);
      }
   }

   static Assembly MyResolveEventHandler(object sender, ResolveEventArgs args) {
      return DefineDynamicAssembly((AppDomain) sender);
   }

   static Assembly DefineDynamicAssembly(AppDomain domain) {
      // Build a dynamic assembly using Reflection Emit API.

      AssemblyName assemblyName = new AssemblyName();
      assemblyName.Name = "MyDynamicAssembly";

      AssemblyBuilder assemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
      ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("MyDynamicModule");
      TypeBuilder typeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public);
      ConstructorBuilder constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, null);
      ILGenerator ilGenerator = constructorBuilder.GetILGenerator();

      ilGenerator.EmitWriteLine("MyDynamicType instantiated!");
      ilGenerator.Emit(OpCodes.Ret);

      typeBuilder.CreateType();

      return assemblyBuilder;
   }
}
open System
open System.Reflection
open System.Reflection.Emit

let instantiateMyDynamicType (domain: AppDomain) =
    try
        // You must supply a valid fully qualified assembly name here.
        domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType")
        |> ignore
    with e ->
        printfn $"{e.Message}"

let defineDynamicAssembly (domain: AppDomain) =
    // Build a dynamic assembly using Reflection Emit API.
    let assemblyName = AssemblyName()
    assemblyName.Name <- "MyDynamicAssembly"

    let assemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run)
    let moduleBuilder = assemblyBuilder.DefineDynamicModule "MyDynamicModule"
    let typeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public)
    let constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, null)
    let ilGenerator = constructorBuilder.GetILGenerator()

    ilGenerator.EmitWriteLine "MyDynamicType instantiated!"
    ilGenerator.Emit OpCodes.Ret

    typeBuilder.CreateType() |> ignore

    assemblyBuilder

let myResolveEventHandler (sender: obj) _ =
    defineDynamicAssembly (sender :?> AppDomain)
    :> Assembly
   
let currentDomain = AppDomain.CurrentDomain

instantiateMyDynamicType currentDomain   // Failed!

currentDomain.add_AssemblyResolve(ResolveEventHandler myResolveEventHandler)

instantiateMyDynamicType currentDomain   // OK!

Imports System.Reflection
Imports System.Reflection.Emit

Module Test
   
   Sub Main()
      Dim currentDomain As AppDomain = AppDomain.CurrentDomain
      
      InstantiateMyDynamicType(currentDomain)   'Failed!
      
      AddHandler currentDomain.AssemblyResolve, AddressOf MyResolveEventHandler
      
      InstantiateMyDynamicType(currentDomain)   'OK!
   End Sub
   
   Sub InstantiateMyDynamicType(domain As AppDomain)
      Try
         ' You must supply a valid fully qualified assembly name here.
         domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType")
      Catch e As Exception
         Console.WriteLine(e.Message)
      End Try
   End Sub
   
   Function MyResolveEventHandler(sender As Object, args As ResolveEventArgs) As System.Reflection.Assembly
      Return DefineDynamicAssembly(DirectCast(sender, AppDomain))
   End Function 'MyResolveEventHandler
   
   Function DefineDynamicAssembly(domain As AppDomain) As System.Reflection.Assembly
      ' Build a dynamic assembly using Reflection Emit API.

      Dim assemblyName As New AssemblyName()
      assemblyName.Name = "MyDynamicAssembly"
      
      Dim assemblyBuilder As AssemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run)
      Dim moduleBuilder As ModuleBuilder = assemblyBuilder.DefineDynamicModule("MyDynamicModule")
      Dim typeBuilder As TypeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public)
      Dim constructorBuilder As ConstructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Nothing)
      Dim ilGenerator As ILGenerator = constructorBuilder.GetILGenerator()
      
      ilGenerator.EmitWriteLine("MyDynamicType instantiated!")
      ilGenerator.Emit(OpCodes.Ret)
      
      typeBuilder.CreateType()
      
      Return assemblyBuilder
   End Function 'DefineDynamicAssembly

End Module 'Test

Remarques

Cette méthode doit uniquement être utilisée pour définir un assembly dynamique dans le domaine d’application actuel. Pour plus d’informations, consultez la surcharge de Load(AssemblyName) méthode.

Notes

Pendant le développement du code qui émet des assemblys dynamiques, il est recommandé d’utiliser une surcharge de la DefineDynamicAssembly méthode qui spécifie des preuves et des autorisations, de fournir la preuve que l’assembly dynamique doit avoir et d’inclure SecurityPermissionFlag.SkipVerification dans refusedPermissions. Le fait d’inclure SkipVerification dans le refusedPermissions paramètre garantit que le MSIL est vérifié. Une limitation de cette technique est qu’elle entraîne SecurityException également la levée lorsqu’elle est utilisée avec du code qui exige une confiance totale.

S’applique à

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, Evidence)

Attention

Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.

Définit un assembly dynamique avec le nom, le mode d'accès et la preuve spécifiés.

public:
 virtual System::Reflection::Emit::AssemblyBuilder ^ DefineDynamicAssembly(System::Reflection::AssemblyName ^ name, System::Reflection::Emit::AssemblyBuilderAccess access, System::Security::Policy::Evidence ^ evidence);
public System.Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (System.Reflection.AssemblyName name, System.Reflection.Emit.AssemblyBuilderAccess access, System.Security.Policy.Evidence evidence);
[System.Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default.  See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
public System.Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (System.Reflection.AssemblyName name, System.Reflection.Emit.AssemblyBuilderAccess access, System.Security.Policy.Evidence evidence);
abstract member DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * System.Security.Policy.Evidence -> System.Reflection.Emit.AssemblyBuilder
override this.DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * System.Security.Policy.Evidence -> System.Reflection.Emit.AssemblyBuilder
[<System.Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default.  See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")>]
abstract member DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * System.Security.Policy.Evidence -> System.Reflection.Emit.AssemblyBuilder
override this.DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * System.Security.Policy.Evidence -> System.Reflection.Emit.AssemblyBuilder
Public Function DefineDynamicAssembly (name As AssemblyName, access As AssemblyBuilderAccess, evidence As Evidence) As AssemblyBuilder

Paramètres

name
AssemblyName

Identité unique de l'assembly dynamique.

access
AssemblyBuilderAccess

Mode d'accès à l'assembly dynamique.

evidence
Evidence

Preuve fournie pour l'assembly dynamique. La preuve est utilisée non modifiée en tant qu’ensemble de preuves final pour la résolution de stratégie.

Retours

Assembly dynamique avec le nom et les fonctionnalités spécifiés.

Implémente

Attributs

Exceptions

name a la valeur null.

La propriété Name de name a la valeur null.

- ou -

La propriété Name de name commence par un espace blanc ou contient une barre oblique ou une barre oblique inverse.

L’opération est tentée sur un domaine d’application non chargé.

Exemples

L’exemple suivant illustre la DefineDynamicAssembly méthode et l’événement AssemblyResolve .

Tout d’abord, l’exemple de code tente de créer un instance de MyDynamicType en appelant la CreateInstance méthode avec un nom d’assembly non valide et intercepte l’exception résultante.

L’exemple de code ajoute ensuite un gestionnaire d’événements pour l’événementAssemblyResolve, puis tente à nouveau de créer un instance deMyDynamicType . Pendant l’appel à CreateInstance, l’événement AssemblyResolve est déclenché pour l’assembly non valide. Le gestionnaire d’événements crée un assembly dynamique qui contient un type nommé MyDynamicType, donne au type un constructeur sans paramètre et retourne le nouvel assembly dynamique. L’appel à CreateInstance se termine alors correctement et le constructeur pour MyDynamicType affiche un message sur la console.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
ref class Test
{
public:
   static void InstantiateMyDynamicType( AppDomain^ domain )
   {
      try
      {
         
         // You must supply a valid fully qualified assembly name here.
         domain->CreateInstance( "Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType" );
      }
      catch ( Exception^ e ) 
      {
         Console::WriteLine( e->Message );
      }

   }

   static Assembly^ MyResolveEventHandler( Object^ sender, ResolveEventArgs^ args )
   {
      return DefineDynamicAssembly( dynamic_cast<AppDomain^>(sender) );
   }

   static Assembly^ DefineDynamicAssembly( AppDomain^ domain )
   {
      
      // Build a dynamic assembly using Reflection Emit API.
      AssemblyName^ assemblyName = gcnew AssemblyName;
      assemblyName->Name = "MyDynamicAssembly";
      AssemblyBuilder^ assemblyBuilder = domain->DefineDynamicAssembly( assemblyName, AssemblyBuilderAccess::Run );
      ModuleBuilder^ moduleBuilder = assemblyBuilder->DefineDynamicModule( "MyDynamicModule" );
      TypeBuilder^ typeBuilder = moduleBuilder->DefineType( "MyDynamicType", TypeAttributes::Public );
      ConstructorBuilder^ constructorBuilder = typeBuilder->DefineConstructor( MethodAttributes::Public, CallingConventions::Standard, nullptr );
      ILGenerator^ ilGenerator = constructorBuilder->GetILGenerator();
      ilGenerator->EmitWriteLine( "MyDynamicType instantiated!" );
      ilGenerator->Emit( OpCodes::Ret );
      typeBuilder->CreateType();
      return assemblyBuilder;
   }

};

int main()
{
   AppDomain^ currentDomain = AppDomain::CurrentDomain;
   Test::InstantiateMyDynamicType( currentDomain ); // Failed!
   currentDomain->AssemblyResolve += gcnew ResolveEventHandler( Test::MyResolveEventHandler );
   Test::InstantiateMyDynamicType( currentDomain ); // OK!
}
using System;
using System.Reflection;
using System.Reflection.Emit;

class DefinedDynamicAssemblySnippet {
   public static void Main() {
      AppDomain currentDomain = AppDomain.CurrentDomain;

      InstantiateMyDynamicType(currentDomain);   // Failed!

      currentDomain.AssemblyResolve += new ResolveEventHandler(MyResolveEventHandler);

      InstantiateMyDynamicType(currentDomain);   // OK!
   }

   static void InstantiateMyDynamicType(AppDomain domain) {
      try {
         // You must supply a valid fully qualified assembly name here.
         domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType");
      } catch (Exception e) {
         Console.WriteLine(e.Message);
      }
   }

   static Assembly MyResolveEventHandler(object sender, ResolveEventArgs args) {
      return DefineDynamicAssembly((AppDomain) sender);
   }

   static Assembly DefineDynamicAssembly(AppDomain domain) {
      // Build a dynamic assembly using Reflection Emit API.

      AssemblyName assemblyName = new AssemblyName();
      assemblyName.Name = "MyDynamicAssembly";

      AssemblyBuilder assemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
      ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("MyDynamicModule");
      TypeBuilder typeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public);
      ConstructorBuilder constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, null);
      ILGenerator ilGenerator = constructorBuilder.GetILGenerator();

      ilGenerator.EmitWriteLine("MyDynamicType instantiated!");
      ilGenerator.Emit(OpCodes.Ret);

      typeBuilder.CreateType();

      return assemblyBuilder;
   }
}
open System
open System.Reflection
open System.Reflection.Emit

let instantiateMyDynamicType (domain: AppDomain) =
    try
        // You must supply a valid fully qualified assembly name here.
        domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType")
        |> ignore
    with e ->
        printfn $"{e.Message}"

let defineDynamicAssembly (domain: AppDomain) =
    // Build a dynamic assembly using Reflection Emit API.
    let assemblyName = AssemblyName()
    assemblyName.Name <- "MyDynamicAssembly"

    let assemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run)
    let moduleBuilder = assemblyBuilder.DefineDynamicModule "MyDynamicModule"
    let typeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public)
    let constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, null)
    let ilGenerator = constructorBuilder.GetILGenerator()

    ilGenerator.EmitWriteLine "MyDynamicType instantiated!"
    ilGenerator.Emit OpCodes.Ret

    typeBuilder.CreateType() |> ignore

    assemblyBuilder

let myResolveEventHandler (sender: obj) _ =
    defineDynamicAssembly (sender :?> AppDomain)
    :> Assembly
   
let currentDomain = AppDomain.CurrentDomain

instantiateMyDynamicType currentDomain   // Failed!

currentDomain.add_AssemblyResolve(ResolveEventHandler myResolveEventHandler)

instantiateMyDynamicType currentDomain   // OK!

Imports System.Reflection
Imports System.Reflection.Emit

Module Test
   
   Sub Main()
      Dim currentDomain As AppDomain = AppDomain.CurrentDomain
      
      InstantiateMyDynamicType(currentDomain)   'Failed!
      
      AddHandler currentDomain.AssemblyResolve, AddressOf MyResolveEventHandler
      
      InstantiateMyDynamicType(currentDomain)   'OK!
   End Sub
   
   Sub InstantiateMyDynamicType(domain As AppDomain)
      Try
         ' You must supply a valid fully qualified assembly name here.
         domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType")
      Catch e As Exception
         Console.WriteLine(e.Message)
      End Try
   End Sub
   
   Function MyResolveEventHandler(sender As Object, args As ResolveEventArgs) As System.Reflection.Assembly
      Return DefineDynamicAssembly(DirectCast(sender, AppDomain))
   End Function 'MyResolveEventHandler
   
   Function DefineDynamicAssembly(domain As AppDomain) As System.Reflection.Assembly
      ' Build a dynamic assembly using Reflection Emit API.

      Dim assemblyName As New AssemblyName()
      assemblyName.Name = "MyDynamicAssembly"
      
      Dim assemblyBuilder As AssemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run)
      Dim moduleBuilder As ModuleBuilder = assemblyBuilder.DefineDynamicModule("MyDynamicModule")
      Dim typeBuilder As TypeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public)
      Dim constructorBuilder As ConstructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Nothing)
      Dim ilGenerator As ILGenerator = constructorBuilder.GetILGenerator()
      
      ilGenerator.EmitWriteLine("MyDynamicType instantiated!")
      ilGenerator.Emit(OpCodes.Ret)
      
      typeBuilder.CreateType()
      
      Return assemblyBuilder
   End Function 'DefineDynamicAssembly

End Module 'Test

Remarques

Seuls les appelants entièrement approuvés peuvent fournir leur evidence lors de la définition d’un dynamique Assembly. Le runtime mappe le Evidence via la stratégie de sécurité pour déterminer les autorisations accordées. Les appelants partiellement approuvés doivent fournir une valeur null evidence. Si evidence a la valeur null, le runtime copie les jeux d’autorisations, c’est-à-dire les jeux d’octroi et de refus actuels, de l’appelant Assembly à la dynamique Assembly en cours de définition et marque la stratégie comme résolue.

Si la dynamique Assembly est enregistrée sur le disque, les charges suivantes recevront des subventions en fonction des stratégies associées à l’emplacement où le Assembly a été enregistré.

Cette méthode doit uniquement être utilisée pour définir un assembly dynamique dans le domaine d’application actuel. Pour plus d’informations, consultez la surcharge de Load(AssemblyName) méthode.

Notes

Pendant le développement de code qui émet des assemblys dynamiques, il est recommandé d’utiliser une surcharge de la méthode qui spécifie les DefineDynamicAssembly preuves et les autorisations, de fournir la preuve que vous souhaitez que l’assembly dynamique ait et d’inclure SecurityPermissionFlag.SkipVerification dans refusedPermissions. L’inclusion SkipVerification dans le refusedPermissions paramètre garantit que le MSIL est vérifié. Une limitation de cette technique est qu’elle provoque également la SecurityException levée lorsqu’elle est utilisée avec du code qui demande une confiance totale.

S’applique à

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, IEnumerable<CustomAttributeBuilder>)

Définit un assembly dynamique avec le nom, le mode d'accès et les attributs personnalisés spécifiés.

public:
 System::Reflection::Emit::AssemblyBuilder ^ DefineDynamicAssembly(System::Reflection::AssemblyName ^ name, System::Reflection::Emit::AssemblyBuilderAccess access, System::Collections::Generic::IEnumerable<System::Reflection::Emit::CustomAttributeBuilder ^> ^ assemblyAttributes);
public System.Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (System.Reflection.AssemblyName name, System.Reflection.Emit.AssemblyBuilderAccess access, System.Collections.Generic.IEnumerable<System.Reflection.Emit.CustomAttributeBuilder> assemblyAttributes);
member this.DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess * seq<System.Reflection.Emit.CustomAttributeBuilder> -> System.Reflection.Emit.AssemblyBuilder
Public Function DefineDynamicAssembly (name As AssemblyName, access As AssemblyBuilderAccess, assemblyAttributes As IEnumerable(Of CustomAttributeBuilder)) As AssemblyBuilder

Paramètres

name
AssemblyName

Identité unique de l'assembly dynamique.

access
AssemblyBuilderAccess

Mode d'accès de l'assembly dynamique.

assemblyAttributes
IEnumerable<CustomAttributeBuilder>

Une liste enumérable d'attributs à appliquer à l'assembly, ou null s'il n'y a pas d'attributs.

Retours

Assembly dynamique avec le nom et les fonctionnalités spécifiés.

Exceptions

name a la valeur null.

La propriété Name de name a la valeur null.

- ou -

La propriété Name de name commence par un espace blanc ou bien contient une barre oblique ou une barre oblique inverse.

L’opération est tentée sur un domaine d’application non chargé.

Exemples

L’exemple de code suivant montre comment créer un assembly dynamique qui a le SecurityTransparentAttribute. L’attribut doit être spécifié en tant qu’élément d’un tableau d’objets CustomAttributeBuilder .

La première étape de la création de CustomAttributeBuilder consiste à obtenir un constructeur pour l’attribut. Le constructeur n’ayant aucun paramètre, la GetConstructor méthode est appelée avec un tableau vide d’objets Type pour représenter les types des paramètres. La deuxième étape consiste à passer l’objet résultant ConstructorInfo au constructeur de la CustomAttributeBuilder classe, ainsi qu’un tableau vide de type Object pour représenter les arguments.

Le résultat CustomAttributeBuilder est ensuite passé à la DefineDynamicAssembly méthode en tant que seul élément d’un tableau.

L’exemple de code définit un module et un type dans le nouvel assembly dynamique, puis affiche les attributs de l’assembly.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
using namespace System::Security;

void main()
{
    // Create a CustomAttributeBuilder for the assembly attribute. 
    // 
    // SecurityTransparentAttribute has a parameterless constructor, 
    // which is retrieved by passing an array of empty types for the
    // constructor's parameter types. The CustomAttributeBuilder is 
    // then created by passing the ConstructorInfo and an empty array
    // of objects to represent the parameters.
    //
    ConstructorInfo^ transparentCtor = 
        SecurityTransparentAttribute::typeid->GetConstructor(
            Type::EmptyTypes);
    CustomAttributeBuilder^ transparent = gcnew CustomAttributeBuilder(
        transparentCtor,
        gcnew array<Object^> {} );
      
    // Create a dynamic assembly using the attribute. The attribute is
    // passed as an array with one element.
    AssemblyName^ aName = gcnew AssemblyName("EmittedAssembly");
    AssemblyBuilder^ ab = AppDomain::CurrentDomain->DefineDynamicAssembly( 
        aName, 
        AssemblyBuilderAccess::Run,
        gcnew array<CustomAttributeBuilder^> { transparent } );

    ModuleBuilder^ mb = ab->DefineDynamicModule( aName->Name );
    TypeBuilder^ tb = mb->DefineType( 
        "MyDynamicType", 
        TypeAttributes::Public );
    tb->CreateType();

    Console::WriteLine("{0}\nAssembly attributes:", ab);
    for each (Attribute^ attr in ab->GetCustomAttributes(true))
    {
        Console::WriteLine("\t{0}", attr);
    }
};

/* This code example produces the following output:

EmittedAssembly, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
Assembly attributes:
        System.Security.SecurityTransparentAttribute
 */
using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Security;

class CustomAttributeBuilderSnippet
{
    static void Main()
    {
        // Create a CustomAttributeBuilder for the assembly attribute.
        //
        // SecurityTransparentAttribute has a parameterless constructor,
        // which is retrieved by passing an array of empty types for the
        // constructor's parameter types. The CustomAttributeBuilder is
        // then created by passing the ConstructorInfo and an empty array
        // of objects to represent the parameters.
        //
        ConstructorInfo transparentCtor =
            typeof(SecurityTransparentAttribute).GetConstructor(
                Type.EmptyTypes);
        CustomAttributeBuilder transparent = new CustomAttributeBuilder(
            transparentCtor,
            new Object[] {} );

        // Create a dynamic assembly using the attribute. The attribute is
        // passed as an array with one element.
        AssemblyName aName = new AssemblyName("EmittedAssembly");
        AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly(
            aName,
            AssemblyBuilderAccess.Run,
            new CustomAttributeBuilder[] { transparent } );

        ModuleBuilder mb = ab.DefineDynamicModule( aName.Name );
        TypeBuilder tb = mb.DefineType(
            "MyDynamicType",
            TypeAttributes.Public );
        tb.CreateType();

        Console.WriteLine("{0}\nAssembly attributes:", ab);
        foreach (Attribute attr in ab.GetCustomAttributes(true))
        {
            Console.WriteLine("\t{0}", attr);
        }
    }
}

/* This code example produces the following output:

EmittedAssembly, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
Assembly attributes:
        System.Security.SecurityTransparentAttribute
 */
open System
open System.Reflection
open System.Reflection.Emit
open System.Security

// Create a CustomAttributeBuilder for the assembly attribute.
//
// SecurityTransparentAttribute has a parameterless constructor,
// which is retrieved by passing an array of empty types for the
// constructor's parameter types. The CustomAttributeBuilder is
// then created by passing the ConstructorInfo and an empty array
// of objects to represent the parameters.
//
let transparentCtor =
    typeof<SecurityTransparentAttribute>.GetConstructor(Type.EmptyTypes)
let transparent = CustomAttributeBuilder(transparentCtor, [||])

// Create a dynamic assembly using the attribute. The attribute is
// passed as an array with one element.
let aName = AssemblyName "EmittedAssembly"
let ab = AppDomain.CurrentDomain.DefineDynamicAssembly(
    aName,
    AssemblyBuilderAccess.Run,
    [| transparent |])

let mb = ab.DefineDynamicModule aName.Name
let tb = mb.DefineType(
    "MyDynamicType",
    TypeAttributes.Public )
tb.CreateType() |> ignore

printfn $"{ab}\nAssembly attributes:"
for attr in ab.GetCustomAttributes true do
    printfn $"\t{attr}"

(* This code example produces the following output:

EmittedAssembly, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
Assembly attributes:
        System.Security.SecurityTransparentAttribute
 *)
Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Security

Module Example

    Sub Main()
    
        ' Create a CustomAttributeBuilder for the assembly attribute. 
        ' 
        ' SecurityTransparentAttribute has a parameterless constructor, 
        ' which is retrieved by passing an array of empty types for the
        ' constructor's parameter types. The CustomAttributeBuilder is 
        ' then created by passing the ConstructorInfo and an empty array
        ' of objects to represent the parameters.
        '
        Dim transparentCtor As ConstructorInfo = _
            GetType(SecurityTransparentAttribute).GetConstructor( _
                Type.EmptyTypes)
        Dim transparent As New CustomAttributeBuilder( _
            transparentCtor, _
            New Object() {} )
      
        ' Create a dynamic assembly Imports the attribute. The attribute is
        ' passed as an array with one element.
        Dim aName As New AssemblyName("EmittedAssembly")
        Dim ab As AssemblyBuilder = _
            AppDomain.CurrentDomain.DefineDynamicAssembly( _
                aName, _
                AssemblyBuilderAccess.Run, _
                New CustomAttributeBuilder() { transparent } )

        Dim mb As ModuleBuilder = ab.DefineDynamicModule( aName.Name )
        Dim tb As TypeBuilder = mb.DefineType( _
            "MyDynamicType", _
            TypeAttributes.Public )
        tb.CreateType()

        Console.WriteLine("{0}" & vbLf & "Assembly attributes:", ab)
        For Each attr As Attribute In ab.GetCustomAttributes(True)
            Console.WriteLine(vbTab & "{0}", attr)
        Next
    End Sub
End Module

' This code example produces the following output:
'
'EmittedAssembly, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
'Assembly attributes:
'        System.Security.SecurityTransparentAttribute

Remarques

Utilisez cette surcharge de méthode pour spécifier des attributs qui ne fonctionnent pas correctement, sauf s’ils sont appliqués lors de la création d’un assembly dynamique. Par exemple, les attributs de sécurité tels que SecurityTransparentAttribute et SecurityCriticalAttribute ne fonctionnent pas correctement s’ils sont ajoutés après la création d’un assembly dynamique.

Cette méthode doit être utilisée uniquement pour définir un assembly dynamique dans le domaine d’application actuel. Pour plus d’informations sur cette restriction, consultez la surcharge de Load(AssemblyName) méthode.

Cette surcharge de méthode est introduite dans .NET Framework 3.5.

Voir aussi

S’applique à

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess)

Définit un assembly dynamique avec le nom et le mode d'accès spécifiés.

public:
 virtual System::Reflection::Emit::AssemblyBuilder ^ DefineDynamicAssembly(System::Reflection::AssemblyName ^ name, System::Reflection::Emit::AssemblyBuilderAccess access);
public System.Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (System.Reflection.AssemblyName name, System.Reflection.Emit.AssemblyBuilderAccess access);
abstract member DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess -> System.Reflection.Emit.AssemblyBuilder
override this.DefineDynamicAssembly : System.Reflection.AssemblyName * System.Reflection.Emit.AssemblyBuilderAccess -> System.Reflection.Emit.AssemblyBuilder
Public Function DefineDynamicAssembly (name As AssemblyName, access As AssemblyBuilderAccess) As AssemblyBuilder

Paramètres

name
AssemblyName

Identité unique de l'assembly dynamique.

access
AssemblyBuilderAccess

Mode d'accès de l'assembly dynamique.

Retours

un assembly dynamique avec le nom et le mode d'accès spécifiés.

Implémente

Exceptions

name a la valeur null.

La propriété Name de name a la valeur null.

- ou -

La propriété Name de name commence par un espace blanc ou contient une barre oblique ou une barre oblique inverse.

L’opération est tentée sur un domaine d’application non chargé.

Exemples

L’exemple suivant illustre la méthode et l’événement DefineDynamicAssemblyAssemblyResolve .

Pour que cet exemple de code s’exécute, vous devez fournir le nom complet de l’assembly. Pour plus d’informations sur la façon d’obtenir le nom complet de l’assembly, consultez Noms d’assembly.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
ref class Test
{
public:
   static void InstantiateMyDynamicType( AppDomain^ domain )
   {
      try
      {
         
         // You must supply a valid fully qualified assembly name here.
         domain->CreateInstance( "Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType" );
      }
      catch ( Exception^ e ) 
      {
         Console::WriteLine( e->Message );
      }

   }

   static Assembly^ MyResolveEventHandler( Object^ sender, ResolveEventArgs^ args )
   {
      return DefineDynamicAssembly( dynamic_cast<AppDomain^>(sender) );
   }

   static Assembly^ DefineDynamicAssembly( AppDomain^ domain )
   {
      
      // Build a dynamic assembly using Reflection Emit API.
      AssemblyName^ assemblyName = gcnew AssemblyName;
      assemblyName->Name = "MyDynamicAssembly";
      AssemblyBuilder^ assemblyBuilder = domain->DefineDynamicAssembly( assemblyName, AssemblyBuilderAccess::Run );
      ModuleBuilder^ moduleBuilder = assemblyBuilder->DefineDynamicModule( "MyDynamicModule" );
      TypeBuilder^ typeBuilder = moduleBuilder->DefineType( "MyDynamicType", TypeAttributes::Public );
      ConstructorBuilder^ constructorBuilder = typeBuilder->DefineConstructor( MethodAttributes::Public, CallingConventions::Standard, nullptr );
      ILGenerator^ ilGenerator = constructorBuilder->GetILGenerator();
      ilGenerator->EmitWriteLine( "MyDynamicType instantiated!" );
      ilGenerator->Emit( OpCodes::Ret );
      typeBuilder->CreateType();
      return assemblyBuilder;
   }

};

int main()
{
   AppDomain^ currentDomain = AppDomain::CurrentDomain;
   Test::InstantiateMyDynamicType( currentDomain ); // Failed!
   currentDomain->AssemblyResolve += gcnew ResolveEventHandler( Test::MyResolveEventHandler );
   Test::InstantiateMyDynamicType( currentDomain ); // OK!
}
using System;
using System.Reflection;
using System.Reflection.Emit;

class DefinedDynamicAssemblySnippet {
   public static void Main() {
      AppDomain currentDomain = AppDomain.CurrentDomain;

      InstantiateMyDynamicType(currentDomain);   // Failed!

      currentDomain.AssemblyResolve += new ResolveEventHandler(MyResolveEventHandler);

      InstantiateMyDynamicType(currentDomain);   // OK!
   }

   static void InstantiateMyDynamicType(AppDomain domain) {
      try {
         // You must supply a valid fully qualified assembly name here.
         domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType");
      } catch (Exception e) {
         Console.WriteLine(e.Message);
      }
   }

   static Assembly MyResolveEventHandler(object sender, ResolveEventArgs args) {
      return DefineDynamicAssembly((AppDomain) sender);
   }

   static Assembly DefineDynamicAssembly(AppDomain domain) {
      // Build a dynamic assembly using Reflection Emit API.

      AssemblyName assemblyName = new AssemblyName();
      assemblyName.Name = "MyDynamicAssembly";

      AssemblyBuilder assemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
      ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("MyDynamicModule");
      TypeBuilder typeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public);
      ConstructorBuilder constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, null);
      ILGenerator ilGenerator = constructorBuilder.GetILGenerator();

      ilGenerator.EmitWriteLine("MyDynamicType instantiated!");
      ilGenerator.Emit(OpCodes.Ret);

      typeBuilder.CreateType();

      return assemblyBuilder;
   }
}
open System
open System.Reflection
open System.Reflection.Emit

let instantiateMyDynamicType (domain: AppDomain) =
    try
        // You must supply a valid fully qualified assembly name here.
        domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType")
        |> ignore
    with e ->
        printfn $"{e.Message}"

let defineDynamicAssembly (domain: AppDomain) =
    // Build a dynamic assembly using Reflection Emit API.
    let assemblyName = AssemblyName()
    assemblyName.Name <- "MyDynamicAssembly"

    let assemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run)
    let moduleBuilder = assemblyBuilder.DefineDynamicModule "MyDynamicModule"
    let typeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public)
    let constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, null)
    let ilGenerator = constructorBuilder.GetILGenerator()

    ilGenerator.EmitWriteLine "MyDynamicType instantiated!"
    ilGenerator.Emit OpCodes.Ret

    typeBuilder.CreateType() |> ignore

    assemblyBuilder

let myResolveEventHandler (sender: obj) _ =
    defineDynamicAssembly (sender :?> AppDomain)
    :> Assembly
   
let currentDomain = AppDomain.CurrentDomain

instantiateMyDynamicType currentDomain   // Failed!

currentDomain.add_AssemblyResolve(ResolveEventHandler myResolveEventHandler)

instantiateMyDynamicType currentDomain   // OK!

Imports System.Reflection
Imports System.Reflection.Emit

Module Test
   
   Sub Main()
      Dim currentDomain As AppDomain = AppDomain.CurrentDomain
      
      InstantiateMyDynamicType(currentDomain)   'Failed!
      
      AddHandler currentDomain.AssemblyResolve, AddressOf MyResolveEventHandler
      
      InstantiateMyDynamicType(currentDomain)   'OK!
   End Sub
   
   Sub InstantiateMyDynamicType(domain As AppDomain)
      Try
         ' You must supply a valid fully qualified assembly name here.
         domain.CreateInstance("Assembly text name, Version, Culture, PublicKeyToken", "MyDynamicType")
      Catch e As Exception
         Console.WriteLine(e.Message)
      End Try
   End Sub
   
   Function MyResolveEventHandler(sender As Object, args As ResolveEventArgs) As System.Reflection.Assembly
      Return DefineDynamicAssembly(DirectCast(sender, AppDomain))
   End Function 'MyResolveEventHandler
   
   Function DefineDynamicAssembly(domain As AppDomain) As System.Reflection.Assembly
      ' Build a dynamic assembly using Reflection Emit API.

      Dim assemblyName As New AssemblyName()
      assemblyName.Name = "MyDynamicAssembly"
      
      Dim assemblyBuilder As AssemblyBuilder = domain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run)
      Dim moduleBuilder As ModuleBuilder = assemblyBuilder.DefineDynamicModule("MyDynamicModule")
      Dim typeBuilder As TypeBuilder = moduleBuilder.DefineType("MyDynamicType", TypeAttributes.Public)
      Dim constructorBuilder As ConstructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Nothing)
      Dim ilGenerator As ILGenerator = constructorBuilder.GetILGenerator()
      
      ilGenerator.EmitWriteLine("MyDynamicType instantiated!")
      ilGenerator.Emit(OpCodes.Ret)
      
      typeBuilder.CreateType()
      
      Return assemblyBuilder
   End Function 'DefineDynamicAssembly

End Module 'Test

Remarques

Cette méthode doit uniquement être utilisée pour définir un assembly dynamique dans le domaine d’application actuel. Pour plus d’informations, consultez la surcharge de Load(AssemblyName) méthode.

Notes

Pendant le développement de code qui émet des assemblys dynamiques, il est recommandé d’utiliser une surcharge de la méthode qui spécifie les DefineDynamicAssembly preuves et les autorisations, de fournir la preuve que vous souhaitez que l’assembly dynamique ait et d’inclure SecurityPermissionFlag.SkipVerification dans refusedPermissions. L’inclusion SkipVerification dans le refusedPermissions paramètre garantit que le MSIL est vérifié. Une limitation de cette technique est qu’elle provoque également la SecurityException levée lorsqu’elle est utilisée avec du code qui demande une confiance totale.

S’applique à