Assembly Classe

Définition

Espace de noms:

System.Reflection

Assembly:

System.Runtime.dll

Source:

Assembly.cs

Représente un assembly, qui est un bloc de construction réutilisable, versionable et auto-décrivant une application Common Language Runtime.

public ref class Assembly abstract : System::Reflection::ICustomAttributeProvider, System::Runtime::Serialization::ISerializable

public abstract class Assembly : System.Reflection.ICustomAttributeProvider, System.Runtime.Serialization.ISerializable

type Assembly = class
    interface ICustomAttributeProvider
    interface ISerializable

Public MustInherit Class Assembly
Implements ICustomAttributeProvider, ISerializable

Héritage

Object

Assembly

Dérivé

System.Reflection.Emit.AssemblyBuilder

Implémente

ICustomAttributeProvider ISerializable

Exemples

L’exemple de code suivant montre comment obtenir l’assembly en cours d’exécution, créer une instance d’un type contenu dans cet assembly et appeler l’une des méthodes du type avec une liaison tardive. À cet effet, l’exemple de code définit une classe nommée Example, avec une méthode nommée SampleMethod. Le constructeur de la classe accepte un entier, utilisé pour calculer la valeur de retour de la méthode.

L’exemple de code illustre également l’utilisation de la méthode GetName pour obtenir un objet AssemblyName qui peut être utilisé pour analyser le nom complet de l’assembly. L’exemple affiche le numéro de version de l’assembly, la propriété CodeBase et la propriété EntryPoint.

using namespace System;
using namespace System::Reflection;
using namespace System::Security::Permissions;

[assembly:AssemblyVersionAttribute("1.0.2000.0")];

public ref class Example
{
private: 
    int factor;

public:
    Example(int f)
    {
        factor = f;
    }

    int SampleMethod(int x) 
    { 
        Console::WriteLine("\nExample->SampleMethod({0}) executes.", x);
        return x * factor;
    }
};

void main()
{
    Assembly^ assem = Example::typeid->Assembly;

    Console::WriteLine("Assembly Full Name:");
    Console::WriteLine(assem->FullName);

    // The AssemblyName type can be used to parse the full name.
    AssemblyName^ assemName = assem->GetName();
    Console::WriteLine("\nName: {0}", assemName->Name);
    Console::WriteLine("Version: {0}.{1}", 
        assemName->Version->Major, assemName->Version->Minor);

    Console::WriteLine("\nAssembly CodeBase:");
    Console::WriteLine(assem->CodeBase);

    // Create an object from the assembly, passing in the correct number and
    // type of arguments for the constructor.
    Object^ o = assem->CreateInstance("Example", false, 
        BindingFlags::ExactBinding, 
        nullptr, gcnew array<Object^> { 2 }, nullptr, nullptr);

    // Make a late-bound call to an instance method of the object.    
    MethodInfo^ m = assem->GetType("Example")->GetMethod("SampleMethod");
    Object^ ret = m->Invoke(o, gcnew array<Object^> { 42 });
    Console::WriteLine("SampleMethod returned {0}.", ret);

    Console::WriteLine("\nAssembly entry point:");
    Console::WriteLine(assem->EntryPoint);
}

/* This code example produces output similar to the following:

Assembly Full Name:
source, Version=1.0.2000.0, Culture=neutral, PublicKeyToken=null

Name: source
Version: 1.0

Assembly CodeBase:
file:///C:/sdtree/AssemblyClass/cpp/source.exe

Example->SampleMethod(42) executes.
SampleMethod returned 84.

Assembly entry point:
UInt32 _mainCRTStartup()
 */

using System;
using System.Reflection;
using System.Security.Permissions;

[assembly:AssemblyVersionAttribute("1.0.2000.0")]

public class Example
{
    private int factor;
    public Example(int f)
    {
        factor = f;
    }

    public int SampleMethod(int x)
    {
        Console.WriteLine("\nExample.SampleMethod({0}) executes.", x);
        return x * factor;
    }

    public static void Main()
    {
        Assembly assem = typeof(Example).Assembly;

        Console.WriteLine("Assembly Full Name:");
        Console.WriteLine(assem.FullName);

        // The AssemblyName type can be used to parse the full name.
        AssemblyName assemName = assem.GetName();
        Console.WriteLine("\nName: {0}", assemName.Name);
        Console.WriteLine("Version: {0}.{1}",
            assemName.Version.Major, assemName.Version.Minor);

        Console.WriteLine("\nAssembly CodeBase:");
        Console.WriteLine(assem.CodeBase);

        // Create an object from the assembly, passing in the correct number
        // and type of arguments for the constructor.
        Object o = assem.CreateInstance("Example", false,
            BindingFlags.ExactBinding,
            null, new Object[] { 2 }, null, null);

        // Make a late-bound call to an instance method of the object.
        MethodInfo m = assem.GetType("Example").GetMethod("SampleMethod");
        Object ret = m.Invoke(o, new Object[] { 42 });
        Console.WriteLine("SampleMethod returned {0}.", ret);

        Console.WriteLine("\nAssembly entry point:");
        Console.WriteLine(assem.EntryPoint);
    }
}

/* This code example produces output similar to the following:

Assembly Full Name:
source, Version=1.0.2000.0, Culture=neutral, PublicKeyToken=null

Name: source
Version: 1.0

Assembly CodeBase:
file:///C:/sdtree/AssemblyClass/cs/source.exe

Example.SampleMethod(42) executes.
SampleMethod returned 84.

Assembly entry point:
Void Main()
 */

Imports System.Reflection
Imports System.Security.Permissions

<assembly: AssemblyVersionAttribute("1.0.2000.0")>

Public Class Example
    Private factor As Integer
    
    Public Sub New(ByVal f As Integer) 
        factor = f
    End Sub 
    
    Public Function SampleMethod(ByVal x As Integer) As Integer 
        Console.WriteLine(vbCrLf & "Example.SampleMethod({0}) executes.", x)
        Return x * factor
    End Function 
    
    Public Shared Sub Main() 
        Dim assem As Assembly = GetType(Example).Assembly
        
        Console.WriteLine("Assembly Full Name:")
        Console.WriteLine(assem.FullName)
        
        ' The AssemblyName type can be used to parse the full name.
        Dim assemName As AssemblyName = assem.GetName()
        Console.WriteLine(vbLf + "Name: {0}", assemName.Name)
        Console.WriteLine("Version: {0}.{1}", assemName.Version.Major, _
            assemName.Version.Minor)
        
        Console.WriteLine(vbLf + "Assembly CodeBase:")
        Console.WriteLine(assem.CodeBase)
        
        ' Create an object from the assembly, passing in the correct number
        ' and type of arguments for the constructor.
        Dim o As Object = assem.CreateInstance("Example", False, _
            BindingFlags.ExactBinding, Nothing, _
            New Object() { 2 }, Nothing, Nothing)
        
        ' Make a late-bound call to an instance method of the object.    
        Dim m As MethodInfo = assem.GetType("Example").GetMethod("SampleMethod")
        Dim ret As Object = m.Invoke(o, New Object() { 42 })
        Console.WriteLine("SampleMethod returned {0}.", ret)
        
        Console.WriteLine(vbCrLf & "Assembly entry point:")
        Console.WriteLine(assem.EntryPoint)
    
    End Sub 
End Class 

' This code example produces output similar to the following:
'
'Assembly Full Name:
'source, Version=1.0.2000.0, Culture=neutral, PublicKeyToken=null
'
'Name: source
'Version: 1.0
'
'Assembly CodeBase:
'file:///C:/sdtree/AssemblyClass/vb/source.exe
'
'Example.SampleMethod(42) executes.
'SampleMethod returned 84.
'
'Assembly entry point:
'Void Main()
'

Remarques

Utilisez la classe Assembly pour charger des assemblys, explorer les métadonnées et les parties constituantes des assemblys, découvrir les types contenus dans les assemblys et créer des instances de ces types.

Pour obtenir un tableau d’objets Assembly représentant les assemblys actuellement chargés dans un domaine d’application (par exemple, le domaine d’application par défaut d’un projet simple), utilisez la méthode AppDomain.GetAssemblies.

Pour charger dynamiquement des assemblys, la classe Assembly fournit les méthodes statiques suivantes (Shared méthodes en Visual Basic). Les assemblys sont chargés dans le domaine d’application où l’opération de chargement se produit.

• La méthode recommandée pour charger des assemblys consiste à utiliser la méthode Load, qui identifie l’assembly à charger par son nom complet (par exemple, « System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 »). La recherche de l’assembly suit les règles décrites dans Comment le runtime localise les assemblys.

• Les méthodes ReflectionOnlyLoad et ReflectionOnlyLoadFrom vous permettent de charger un assembly pour la réflexion, mais pas pour l’exécution. Par exemple, un assembly qui cible une plateforme 64 bits peut être examiné par le code qui s’exécute sur une plateforme 32 bits.

• Les méthodes LoadFile et LoadFrom sont fournies pour les scénarios rares dans lesquels un assembly doit être identifié par chemin d’accès.

Pour obtenir un objet Assembly pour l’assembly en cours d’exécution, utilisez la méthode GetExecutingAssembly.

De nombreux membres de la classe Assembly fournissent des informations sur un assembly. Par exemple:

• La méthode GetName retourne un objet AssemblyName qui fournit l’accès aux parties du nom d’affichage de l’assembly.

• La méthode GetCustomAttributes répertorie les attributs appliqués à l’assembly.

• La méthode GetFiles permet d’accéder aux fichiers du manifeste d’assembly.

• La méthode GetManifestResourceNames fournit les noms des ressources dans le manifeste d’assembly.

La méthode GetTypes répertorie tous les types de l’assembly. La méthode GetExportedTypes répertorie les types visibles par les appelants en dehors de l’assembly. La méthode GetType peut être utilisée pour rechercher un type particulier dans l’assembly. La méthode CreateInstance peut être utilisée pour rechercher et créer des instances de types dans l’assembly.

Pour plus d’informations sur les assemblys, consultez la section « Domaines et assemblys d’application » dans la rubrique Domaines d’application.

Constructeurs

Assembly()

Initialise une nouvelle instance de la classe Assembly.

Propriétés

CodeBase	Obsolète. Obtient l’emplacement de l’assembly comme spécifié à l’origine, par exemple dans un objet AssemblyName.
CustomAttributes	Obtient une collection qui contient les attributs personnalisés de cet assembly.
DefinedTypes	Obtient une collection des types définis dans cet assembly.
EntryPoint	Obtient le point d’entrée de cet assembly.
EscapedCodeBase	Obsolète. Obtient l’URI, y compris les caractères d’échappement, qui représente la base de code.
ExportedTypes	Obtient une collection des types publics définis dans cet assembly qui sont visibles en dehors de l’assembly.
FullName	Obtient le nom complet de l’assembly.
GlobalAssemblyCache	Obsolète. Obtient une valeur indiquant si l’assembly a été chargé à partir du Global Assembly Cache (.NET Framework uniquement).
HostContext	Obtient le contexte hôte avec lequel l’assembly a été chargé.
ImageRuntimeVersion	Obtient une chaîne représentant la version du Common Language Runtime (CLR) enregistrée dans le fichier contenant le manifeste.
IsCollectible	Obtient une valeur qui indique si cet assembly est conservé dans un AssemblyLoadContextcollectible.
IsDynamic	Obtient une valeur qui indique si l’assembly actuel a été généré dynamiquement dans le processus actuel à l’aide de l’émission de réflexion.
IsFullyTrusted	Obtient une valeur qui indique si l’assembly actuel est chargé avec une confiance totale.
Location	Obtient le chemin d’accès complet ou l’emplacement UNC du fichier chargé qui contient le manifeste.
ManifestModule	Obtient le module qui contient le manifeste de l’assembly actuel.
Modules	Obtient une collection qui contient les modules de cet assembly.
ReflectionOnly	Obtient une valeur Boolean indiquant si cet assembly a été chargé dans le contexte de réflexion uniquement.
SecurityRuleSet	Obtient une valeur qui indique l’ensemble de règles de sécurité appliquées par le Common Language Runtime (CLR) pour cet assembly.

Méthodes

CreateInstance(String)	Localise le type spécifié à partir de cet assembly et crée une instance de celui-ci à l’aide de l’activateur système, à l’aide de la recherche sensible à la casse.
CreateInstance(String, Boolean)	Recherche le type spécifié à partir de cet assembly et crée une instance de celui-ci à l’aide de l’activateur système, avec une recherche facultative sensible à la casse.
CreateInstance(String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])	Recherche le type spécifié à partir de cet assembly et crée une instance de celui-ci à l’aide de l’activateur système, avec recherche facultative sensible à la casse et ayant la culture, les arguments et les attributs d’activation et de liaison spécifiés.
CreateQualifiedName(String, String)	Crée le nom d’un type qualifié par le nom complet de son assembly.
Equals(Object)	Détermine si cet assembly et l’objet spécifié sont égaux.
GetAssembly(Type)	Obtient l’assembly actuellement chargé dans lequel le type spécifié est défini.
GetCallingAssembly()	Retourne la Assembly de la méthode qui a appelé la méthode en cours d’exécution.
GetCustomAttributes(Boolean)	Obtient tous les attributs personnalisés pour cet assembly.
GetCustomAttributes(Type, Boolean)	Obtient les attributs personnalisés pour cet assembly, comme spécifié par type.
GetCustomAttributesData()	Retourne des informations sur les attributs qui ont été appliqués au Assemblyactuel, exprimées sous forme d’objets CustomAttributeData.
GetEntryAssembly()	Obtient l’assembly d’entrée pour l’application en cours d’exécution.
GetExecutingAssembly()	Obtient l’assembly qui contient le code en cours d’exécution.
GetExportedTypes()	Obtient les types publics définis dans cet assembly qui sont visibles en dehors de l’assembly.
GetFile(String)	Obtient une FileStream pour le fichier spécifié dans la table de fichiers du manifeste de cet assembly.
GetFiles()	Obtient les fichiers dans la table de fichiers d’un manifeste d’assembly.
GetFiles(Boolean)	Obtient les fichiers dans la table de fichiers d’un manifeste d’assembly, en spécifiant s’il faut inclure des modules de ressources.
GetForwardedTypes()	Représente un assembly, qui est un bloc de construction réutilisable, versionable et auto-décrivant une application Common Language Runtime.
GetHashCode()	Retourne le code de hachage pour cette instance.
GetLoadedModules()	Obtient tous les modules chargés qui font partie de cet assembly.
GetLoadedModules(Boolean)	Obtient tous les modules chargés qui font partie de cet assembly, en spécifiant s’il faut inclure des modules de ressources.
GetManifestResourceInfo(String)	Retourne des informations sur la façon dont la ressource donnée a été conservée.
GetManifestResourceNames()	Retourne les noms de toutes les ressources de cet assembly.
GetManifestResourceStream(String)	Charge la ressource de manifeste spécifiée à partir de cet assembly.
GetManifestResourceStream(Type, String)	Charge la ressource de manifeste spécifiée, délimitée par l’espace de noms du type spécifié, à partir de cet assembly.
GetModule(String)	Obtient le module spécifié dans cet assembly.
GetModules()	Obtient tous les modules qui font partie de cet assembly.
GetModules(Boolean)	Obtient tous les modules qui font partie de cet assembly, en spécifiant s’il faut inclure des modules de ressources.
GetName()	Obtient une AssemblyName pour cet assembly.
GetName(Boolean)	Obtient une AssemblyName pour cet assembly, en définissant la base de code comme spécifié par copiedName.
GetObjectData(SerializationInfo, StreamingContext)	Obsolète. Obtient des informations de sérialisation avec toutes les données nécessaires pour réinstancier cet assembly.
GetReferencedAssemblies()	Obtient les objets AssemblyName pour tous les assemblys référencés par cet assembly.
GetSatelliteAssembly(CultureInfo)	Obtient l’assembly satellite pour la culture spécifiée.
GetSatelliteAssembly(CultureInfo, Version)	Obtient la version spécifiée de l’assembly satellite pour la culture spécifiée.
GetType()	Obtient la Type de l’instance actuelle. (Hérité de Object)
GetType(String)	Obtient l’objet Type avec le nom spécifié dans l’instance d’assembly.
GetType(String, Boolean)	Obtient l’objet Type portant le nom spécifié dans l’instance d’assembly et lève éventuellement une exception si le type est introuvable.
GetType(String, Boolean, Boolean)	Obtient l’objet Type portant le nom spécifié dans l’instance d’assembly, avec les options d’ignorer le cas et de lever une exception si le type est introuvable.
GetTypes()	Obtient tous les types définis dans cet assembly.
IsDefined(Type, Boolean)	Indique si un attribut spécifié a été appliqué ou non à l’assembly.
Load(AssemblyName)	Charge un assembly en fonction de son AssemblyName.
Load(Byte[])	Charge l’assembly avec une image COFF (Common Object File Format) contenant un assembly émis.
Load(Byte[], Byte[])	Charge l’assembly avec une image COFF (Common Object File Format) contenant un assembly émis, y compris éventuellement des symboles pour l’assembly.
Load(String)	Charge un assembly avec le nom spécifié.
LoadFile(String)	Charge le contenu d’un fichier d’assembly sur le chemin d’accès spécifié.
LoadFrom(String)	Charge un assembly en fonction de son nom de fichier ou de son chemin d’accès.
LoadFrom(String, Byte[], AssemblyHashAlgorithm)	Charge un assembly en fonction du nom de fichier ou du chemin d’accès, de la valeur de hachage et de l’algorithme de hachage.
LoadModule(String, Byte[])	Charge le module, interne à cet assembly, avec une image COFF (Common Object File Format) contenant un module émis ou un fichier de ressources.
LoadModule(String, Byte[], Byte[])	Charge le module, interne à cet assembly, avec une image COFF (Common Object File Format) contenant un module émis ou un fichier de ressources. Les octets bruts représentant les symboles du module sont également chargés.
LoadWithPartialName(String)	Obsolète. Charge un assembly à partir du répertoire de l’application ou du Global Assembly Cache à l’aide d’un nom partiel.
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (Hérité de Object)
ReflectionOnlyLoad(Byte[])	Obsolète. Charge l’assembly à partir d’une image COFF (Common Object File Format) contenant un assembly émis. L’assembly est chargé dans le contexte de réflexion uniquement du domaine d’application de l’appelant.
ReflectionOnlyLoad(String)	Obsolète. Charge un assembly dans le contexte de réflexion uniquement, en fonction de son nom complet.
ReflectionOnlyLoadFrom(String)	Obsolète. Charge un assembly dans le contexte de réflexion uniquement, en fonction de son chemin d’accès.
ToString()	Retourne le nom complet de l’assembly, également appelé nom d’affichage.
UnsafeLoadFrom(String)	Charge un assembly dans le contexte de chargement à partir du contexte, en contournant certaines vérifications de sécurité.

Opérateurs

Equality(Assembly, Assembly)	Indique si deux objets Assembly sont égaux.
Inequality(Assembly, Assembly)	Indique si deux objets Assembly ne sont pas égaux.

Événements

ModuleResolve

Se produit lorsque le chargeur de classe Common Language Runtime ne peut pas résoudre une référence à un module interne d’un assembly par le biais de moyens normaux.

Méthodes d’extension

GetExportedTypes(Assembly)	Représente un assembly, qui est un bloc de construction réutilisable, versionable et auto-décrivant une application Common Language Runtime.
GetModules(Assembly)	Représente un assembly, qui est un bloc de construction réutilisable, versionable et auto-décrivant une application Common Language Runtime.
GetTypes(Assembly)	Représente un assembly, qui est un bloc de construction réutilisable, versionable et auto-décrivant une application Common Language Runtime.
GetCustomAttribute(Assembly, Type)	Récupère un attribut personnalisé d’un type spécifié appliqué à un assembly spécifié.
GetCustomAttribute<T>(Assembly)	Récupère un attribut personnalisé d’un type spécifié appliqué à un assembly spécifié.
GetCustomAttributes(Assembly)	Récupère une collection d’attributs personnalisés appliqués à un assembly spécifié.
GetCustomAttributes(Assembly, Type)	Récupère une collection d’attributs personnalisés d’un type spécifié qui sont appliqués à un assembly spécifié.
GetCustomAttributes<T>(Assembly)	Récupère une collection d’attributs personnalisés d’un type spécifié qui sont appliqués à un assembly spécifié.
IsDefined(Assembly, Type)	Indique si les attributs personnalisés d’un type spécifié sont appliqués à un assembly spécifié.
TryGetRawMetadata(Assembly, Byte*, Int32)	Récupère la section de métadonnées de l’assembly, à utiliser avec MetadataReader.

Cohérence de thread

Ce type est thread safe.

Voir aussi

• AppDomain
• AssemblyName
• domaines d’application