Partager via

Assemblies dans .NET

Les assemblies sont les unités fondamentales du déploiement, du contrôle de version, de la réutilisation, de l'étendue de l'activation et des autorisations de sécurité pour les applications basées sur .NET. Un assembly est une collection de types et de ressources créés pour fonctionner ensemble et former une unité logique de fonctionnalités. Les assemblys prennent la forme de fichiers exécutables (.exe) ou 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 générer un assembly à partir d’un ou plusieurs fichiers de code source. Dans .NET Framework, les assemblys peuvent contenir un ou plusieurs modules. De cette façon, des projets plus volumineux peuvent être planifiés afin que plusieurs développeurs puissent travailler sur des fichiers ou modules de code source distincts, qui sont combinés pour créer un assembly unique. Pour plus d’informations sur les modules, consultez Comment générer un assembly multifichier.

Les assemblages ont les propriétés suivantes :

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

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

  • Les assemblies sont chargés en mémoire uniquement s’ils sont requis. S’ils ne sont pas utilisés, ils ne sont pas chargés. Par conséquent, les assemblages peuvent être un moyen efficace de gérer les ressources dans des projets de plus grande envergure.

  • 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 MetadataLoadContext classe sur .NET et .NET Framework. MetadataLoadContext remplace les Assembly.ReflectionOnlyLoad méthodes.

Assemblages 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 assemblage présente les informations suivantes :

  • Code exécuté par le Common Language Runtime. Chaque assembly ne peut avoir qu’un seul point d’entrée : DllMain, WinMainou 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 assemblies, consultez Considérations de sécurité pour les assemblies.

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

  • Limite d’étendue de référence : le manifeste d’assembly a 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'assemblage et énumère d'autres assemblages dont il dépend. Le code CIL (Common Intermediate Language) dans un fichier exécutable portable (PE) ne sera pas exécuté, sauf s’il a un manifeste d’assembly associé.

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

  • Unité de déploiement : quand une application démarre, seuls les assemblys que l’application appelle initialement doivent être présents. Les autres assemblies, comme les ressources de localisation ou les assemblies contenant des classes utilitaires, peuvent être récupérés à la demande. Ce processus permet aux applications d’être simples et minces lors du premier téléchargement. Pour plus d’informations sur le déploiement d’assemblys, consultez Déployer des 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 un 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, qui sont exécutés directement à partir de la mémoire et qui ne sont pas enregistrés sur le disque avant l’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 des outils de développement, tels que Visual Studio, qui peuvent créer des fichiers.dll ou .exe . Vous pouvez utiliser des outils dans le Kit de développement logiciel (SDK) Windows pour créer des assemblys avec des modules à partir d’autres environnements de développement. Vous pouvez également utiliser des API Common Language Runtime, telles que System.Reflection.Emit, pour créer des assemblys dynamiques.

Compilez des assemblys en les créant dans Visual Studio, en les créant avec les outils d’interface de ligne de commande .NET Core ou en créant des assemblys .NET Framework avec un compilateur de ligne de commande. Pour plus d’informations sur la création d’assemblys à l’aide de l’interface CLI .NET, consultez la vue d’ensemble de l’interface CLI .NET.

Remarque

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

Manifeste d'assembly

Chaque assembly a un fichier manifeste d’assembly . Comme pour 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 assemblies que vous avez créés et qui sont utilisés par votre fichier .exe ou .dll, des fichiers bitmap ou des fichiers Readme.

  • Une liste de référence d’assembly, 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 couplé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 se trouver au niveau d’un répertoire au niveau ou en dessous du répertoire dans lequel votre application est installée.

Les assemblys contiennent des informations sur le contenu, le contrôle de version et les dépendances. Ainsi, 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 assemblies réduisent les conflits .dll et rendent vos applications plus fiables et plus faciles à déployer. Dans de nombreux cas, vous pouvez installer une application basée sur .NET simplement en copiant ses fichiers sur l'ordinateur cible. Pour plus d’informations, consultez le manifeste d’Assembly.

Ajouter une référence à un assembly

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

Remarque

La plupart des assemblys 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 manières 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 .
  • Pour .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’option -reference de ligne de commande pour les compilateurs C# ou Visual Basic .

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

Contenu connexe

Titre Descriptif
Contenu de l'assemblage Éléments qui composent un assemblage.
Manifeste d’assembly Les données dans le manifeste d’assemblage et comment elles sont stockées dans des assemblages.
Global Assembly Cache Comment le GAC stocke et utilise des assemblages.
Assemblies avec nom fort Caractéristiques des assemblies avec nom fort.
Aspects de la sécurité des assemblies Comment fonctionne la sécurité avec les assemblées.
Contrôle de version des assemblies Vue d’ensemble de la stratégie de contrôle de version .NET Framework.
Positionnement de l'assemblage Où localiser les assemblies.
Assemblies et exécution côte à côte Utilisez simultanément plusieurs versions du runtime ou d’un assembly.
Émettre des méthodes et des assemblys dynamiques Comment créer des assemblys dynamiques.
Comment le runtime localise les assemblys Comment .NET Framework résout les références d’assembly au moment de l’exécution.

Référence

System.Reflection.Assembly

Voir aussi