Assemblys dans .NET

  • Article

Les assemblys constituent des unités fondamentales dans le déploiement, la gestion de version, la portée d’activation et les autorisations de sécurité des applications .NET. Un assembly est une collection de types et de ressources conçus pour opérer ensemble et former une unité logique de fonctionnalité. Les assemblys prennent la forme d’un fichier exécutable (.exe) ou d’un fichier de bibliothèque de liens dynamiques (.dll) et sont les blocs de construction des applications .NET. Ils fournissent au Common Language Runtime les informations dont il a besoin pour connaître les implémentations de type.

Dans .NET et .NET Framework, vous pouvez créer un assembly à partir d’un ou plusieurs fichiers de code source. Dans .NET Framework, les assemblys peuvent contenir un ou plusieurs modules. Ainsi, les projets plus importants peuvent être planifiés, permettant à plusieurs développeurs de travailler sur des modules ou fichiers de code source distincts, qui sont regroupés pour créer un assembly unique. Pour plus d’informations sur les modules, consultez la rubrique Comment générer un assembly multifichier.

Les assemblys ont les propriétés suivantes :

  • Les assemblys sont implémentés en tant que fichiers .exe ou .dll.

  • Pour les bibliothèques qui ciblent .NET Framework, vous pouvez partager un assembly entre des applications en les plaçant dans le Global Assembly Cache (GAC). Vous devez définir des assemblys de nom fort avant de pouvoir les inclure dans le GAC. Pour plus d’informations, consultez Assemblys avec nom fort.

  • Les assemblys sont chargés en mémoire uniquement s’ils sont requis. S’ils ne sont pas utilisés, ils ne sont pas chargés. Cela signifie que les assemblys peuvent être un moyen efficace pour gérer les ressources dans les grands projets.

  • Vous pouvez obtenir par programme des informations sur un assembly à l’aide de la réflexion. Pour plus d’informations, consultez Réflexion (C#) ou Réflexion (Visual Basic).

  • Vous pouvez charger un assembly simplement pour l’inspecter à l’aide de la classe MetadataLoadContext sur .NET et .NET Framework. MetadataLoadContext remplace les Assembly.ReflectionOnlyLoad méthodes.

Assemblys dans le Common Language Runtime

Les Assemblys fournissent au Common Language Runtime les informations dont il a besoin pour connaître les implémentations de type. Pour le runtime, un type n'existe pas en dehors du contexte d'un assembly.

Un assembly définit les informations suivantes :

  • Le code que le Common Language Runtime exécute. Notez que chaque assembly ne peut comporter qu'un seul point d'entrée : DllMain, WinMain ou Main.

  • Limite de sécurité. Un assembly est l'unité au niveau de laquelle les autorisations sont demandées et octroyées. Pour plus d’informations sur les limites de sécurité dans les assemblys, consultez Aspects de la sécurité des assemblys.

  • Limite de type. L'identité de chaque type inclut le nom de l'assembly dans lequel il réside. Un type appelé MyType chargé dans l'étendue d'un assembly n'est pas le même qu'un type appelé MyType chargé dans l'étendue d'un autre assembly.

  • Limite d’étendue de référence. Le manifeste de l'assembly contient des métadonnées utilisées pour résoudre les types et satisfaire les demandes de ressources. Le manifeste spécifie les types et ressources à exposer en dehors de l’assembly et énumère d’autres assemblys sur lesquels il dépend. Le code MSIL (Microsoft Intermediate Language) d’un fichier exécutable portable (PE) n'est pas exécuté s'il n'est pas associé à un manifeste d'assembly.

  • Limite de version. L’assembly est la plus petite unité pouvant être versionnable dans le Common Language Runtime. Tous les types et ressources du même assembly sont versionnés en tant qu’unité. Le manifeste de l'assembly décrit les dépendances de version que vous spécifiez pour les assemblys dépendants. Pour plus d’informations sur le contrôle de version, consultez Contrôle de version des assemblys.

  • Unité de déploiement. Quand une application démarre, seuls les assemblys qu'elle appelle initialement doivent être présents. Les autres assemblys, comme les ressources de localisation ou de classes utilitaires, peuvent être récupérés à la demande. Cela permet aux applications d’être simples et légères lors de leur premier téléchargement. Pour plus d’informations sur le déploiement des assemblys, consultez Déploiement d’applications.

  • Unité d’exécution côte à côte. Pour plus d’informations sur l’exécution de plusieurs versions d’un assembly, consultez Assemblys et exécution côte à côte.

Créer un assembly

Les assemblys peuvent être statiques ou dynamiques. Les assemblys statiques sont stockés sur le disque dans des fichiers exécutables portables (PE). Les assemblys statiques peuvent inclure des interfaces, des classes et des ressources telles que des bitmaps, des fichiers JPEG et d’autres fichiers de ressources. Vous pouvez également créer des assemblys dynamiques, directement exécutés à partir de la mémoire et non enregistrés sur le disque avant leur exécution. Vous pouvez enregistrer des assemblys dynamiques sur le disque une fois qu'ils ont été exécutés.

Pour créer des assemblys, différentes possibilités s'offrent à vous. Vous pouvez utiliser les outils de développement, comme Visual Studio, pour créer des fichiers .dll ou .exe. Vous pouvez utiliser les outils du SDK Windows pour créer des assemblys avec des modules provenant d’autres environnements de développement. Vous pouvez également utiliser les API du Common Language Runtime, comme System.Reflection.Emit, pour créer des assemblys dynamiques.

Compilez les assemblys en les générant dans Visual Studio, dans les outils d’interface de ligne de commande de .NET Core, ou générez les assemblys .NET Framework à partir d’un compilateur de ligne de commande. Pour plus d’informations sur la création des assemblys en utilisant l’interface de ligne de commande .NET, consultez Vue d’ensemble de l’interface de ligne de commande .NET.

Notes

Pour générer un assembly dans Visual Studio, dans le menu Générer, sélectionnez Générer.

Manifeste d'assembly

Tous les assemblys contiennent un fichier manifeste d’assembly. Semblable à une table des matières, le manifeste d’assembly contient :

  • L’identité de l’assembly (nom et version).

  • Une table de fichiers décrivant tous les autres fichiers qui composent l’assembly. Par exemple, les autres assemblys que vous avez créés et qui sont utilisés par votre fichier .exe ou .dll, ainsi que des fichiers bitmap ou Readme.

  • Une liste de références d’assemblys, qui est une liste de toutes les dépendances externes, telles que les .dlls ou d’autres fichiers. Les références de l’assembly contiennent des références aux objets globaux et privés. Les objets globaux sont disponibles pour toutes les autres applications. Dans .NET Core, les objets globaux sont associés à un runtime .NET Core particulier. Dans .NET Framework, les objets globaux résident dans le Global Assembly Cache (GAC). System.IO.dll est un exemple d’assembly dans le GAC. Les objets privés doivent être dans un niveau de répertoire ou dans un niveau inférieur que celui du répertoire dans lequel votre application est installée.

Étant donné que les assemblys contiennent des informations sur le contenu, le contrôle de version et les dépendances, les applications qui les utilisent n’ont pas besoin de s’appuyer sur des sources externes, telles que le registre sur les systèmes Windows, pour fonctionner correctement. Les assemblys réduisent les conflits de fichiers .dll et rendent vos applications plus fiables et plus faciles à déployer. Dans de nombreux cas, vous pouvez installer une application .NET simplement en copiant ses fichiers sur l’ordinateur cible. Pour plus d’informations, consultez Manifeste d’assembly.

Ajouter une référence à un assembly.

Pour utiliser un assembly dans une application, vous devez lui ajouter une référence. Une fois qu’un assembly est référencé, tous les types, propriétés, méthodes accessibles et les autres membres de ses espaces de noms sont disponibles pour votre application comme si leur code faisait partie de votre fichier source.

Notes

La plupart des assemblys à partir de la bibliothèque de classes .NET sont référencés automatiquement. Si un assembly système n’est pas automatiquement référencé, ajoutez une référence de l’une des façons suivantes :

  • Pour .NET et .NET Core, ajoutez une référence au package NuGet qui contient l’assembly. Utilisez le Gestionnaire de package NuGet dans Visual Studio ou ajoutez un élément <PackageReference> pour l’assembly au projet .csproj ou .vbproj .
  • Dans .NET Framework, ajoutez une référence à l’assembly à l’aide de la boîte de dialogue Ajouter une référence dans Visual Studio ou à l’aide de l’-referenceoption de ligne de commande pour les compilateurs C# ou Visual Basic.

En C#, vous pouvez utiliser deux versions du même assembly dans une même application. Pour plus d’informations, consultez extern alias.

Contenu connexe

Titre Description
Contenu d’assembly Des éléments qui constituent un assembly.
Manifeste de l'assembly Des données incluses dans le manifeste d'assembly et la manière dont elles sont stockées dans les assemblys.
Global Assembly Cache Comment le GAC stocke et utilise des assemblys.
Assemblys avec nom fort Caractéristiques des assemblys nommés fort.
Aspects de la sécurité des assemblys Comment la sécurité fonctionne avec les assemblys.
Contrôle de version des assemblys Vue d'ensemble de la stratégie de contrôle de version du .NET Framework.
Emplacement d’assembly Où localiser des assemblys.
Assemblys et exécution côte à côte Utiliser simultanément plusieurs versions du runtime ou d'un assembly.
Envoyer des assemblys et des méthodes dynamiques Comment créer des assemblys dynamiques.
Méthode de localisation des assemblys par le runtime Comment le .NET Framework résout les références d'assembly au moment de l'exécution.

Informations de référence

System.Reflection.Assembly

Voir aussi