Assemblys pouvant être collectés pour la génération de type dynamique

Les assemblages récupérables sont des assemblages dynamiques qui peuvent être déchargés sans décharger le domaine d'application dans lequel ils ont été créés. Toute la mémoire managée et non managée utilisée par un assembly collectable, ainsi que les types qu'il contient, peut être récupérée. Les informations telles que le nom du module sont supprimées des tables internes.

Pour activer le déchargement, utilisez l’indicateur AssemblyBuilderAccess.RunAndCollect lorsque vous créez un assembly dynamique. L'assembly est temporaire (c'est-à-dire, il ne peut pas être sauvegardé) et est soumis à des limitations décrites dans la section Restrictions sur les assemblies collectables. Le Common Language Runtime (CLR) décharge automatiquement un assembly collectible lorsque vous relâchez tous les objets associés à l’assembly. À tous les autres égards, les assemblages collectables sont créés et utilisés de la même manière que d'autres assemblages dynamiques.

Durée de vie des assemblys pouvant être collectés

La durée de vie d’un assembly pouvant être collecté est contrôlée par l’existence de références aux types qu’il contient et aux objets qui sont créés à partir de ces types. Le Common Language Runtime ne décharge pas d’assembly tant qu’un ou plusieurs des éléments suivants existent (T est tout type défini dans l’assembly) :

• Instance de T.

• Instance d’un tableau de T.

• Instance d’un type générique qui a T l’un de ses arguments de type. Cela inclut des collections génériques de T, même si cette collection est vide.

• Instance de Type ou TypeBuilder qui représente T.

  Importante

  Vous devez libérer tous les objets qui représentent des parties de l’assemblage. Celui ModuleBuilder qui définit T conserve une référence au TypeBuilder, et l’objet AssemblyBuilder conserve une référence au ModuleBuilder, de sorte que les références à ces objets doivent être libérées. Même l’existence d’un LocalBuilder ou d’un ILGenerator utilisé dans la construction de T empêche le déchargement.

• Référence statique à T par un autre type T1 qui est défini dynamiquement et qui reste accessible en exécutant du code. Par exemple, T1 peut dériver de T, ou T peut être le type d’un paramètre dans une méthode de T1.

• Un ByRef vers un champ statique appartenant à T.

• Un RuntimeTypeHandle, RuntimeFieldHandle ou RuntimeMethodHandle qui fait référence à T ou à un composant de T.

• Instance d’un objet de réflexion qui peut être utilisé indirectement ou directement pour accéder à l’objet Type qui représente T. Par exemple, l’objet Type pour T peut être obtenu à partir d’un type de tableau dont le type d’élément est T, ou à partir d’un type générique qui a T comme argument de type.

• M une méthode sur la pile des appels de n'importe quel thread, où M est une méthode de T ou une méthode au niveau du module définie dans l'assembly.

• Délégué à une méthode statique définie dans un module de l’assembly.

Si un seul élément de cette liste existe pour un seul type ou une seule méthode dans l’assembly, le runtime ne peut pas décharger l’assembly.

À des fins de durée de vie de suivi, un type générique construit tel que List<int> (en C#) ou List(Of Integer) (en Visual Basic) créé et utilisé dans la génération d’un assembly collectible est considéré comme ayant été défini dans l’assembly qui contient la définition de type générique ou dans un assembly qui contient la définition d’un de ses arguments de type. L’assembly exact utilisé est un détail d’implémentation et peut être modifié.

Restrictions sur les assemblys pouvant être collectés

Les restrictions suivantes s’appliquent aux ensembles de collection :

• Références statiques

  Les types d’un assembly dynamique ordinaire ne peuvent pas avoir de références statiques aux types définis dans un assembly collectible. Par exemple, si vous définissez un type simple qui hérite d’un type dans un assembly pouvant être collecté, une exception NotSupportedException est levée. Un type dans un assembly collectible peut avoir des références statiques à un type dans un autre assembly collectible, mais cela étend la durée de vie de l’assembly référencé à la durée de vie de l’assembly de référencement.

Les restrictions suivantes s’appliquent aux assemblys collectibles dans .NET Framework :

• Interopérabilité COM

  Aucune interface COM ne peut être définie dans un assembly collectible, et aucune instance de types au sein d’un assembly collectible ne peut être convertie en objets COM. Un type dans un assembly pouvant être collecté ne peut pas servir de wrapper CCW (COM Callable Wrapper) ni de wrapper RCW (Runtime Callable Wrapper). Toutefois, les types dans les assemblys collectibles peuvent utiliser des objets qui implémentent des interfaces COM.

• Invocation de plateforme

  Les méthodes avec l’attribut DllImportAttribute ne sont pas compilées quand elles sont déclarées dans un assembly pouvant être collecté. L’instruction OpCodes.Calli ne peut pas être utilisée dans l’implémentation d’un type dans un assembly collectible, et ces types ne peuvent pas être marshalés en code non managé. Toutefois, vous pouvez effectuer un appel en code natif à l’aide d’un point d’entrée qui est déclaré dans un assembly ne pouvant pas être collecté.

• Marshaling

  Les objets (en particulier, les délégués) qui sont définis dans les assemblys pouvant être collectés ne peuvent pas être marshalés. Il s’agit d’une restriction sur tous les types émis transitoires.

• Chargement de l'assemblage

  L’émission de réflexion est le seul mécanisme qui est pris en charge pour le chargement des assemblys pouvant être collectés. Les assemblys chargés à l’aide de toute autre forme de chargement d’assembly ne peuvent pas être déchargés.

• Objets liés au contexte

  Les variables statiques contextuelles ne sont pas prises en charge. Les types dans un assembly pouvant être collecté ne peuvent pas étendre ContextBoundObject. Toutefois, le code dans les assemblys collectibles peut utiliser des objets liés au contexte qui sont définis ailleurs.

• Données statiques de thread

  Les variables statiques de thread ne sont pas prises en charge.

Les restrictions suivantes s’appliquent aux assemblys collectibles dans .NET Framework et les versions .NET antérieures à .NET 9 :

• Champs statiques avec FixedAddressValueTypeAttribute

  Les champs statiques définis dans les assemblys collectibles ne peuvent pas avoir l’attribut FixedAddressValueTypeAttribute appliqué.

Voir aussi

• Émission d'assemblys et de méthodes dynamiques