AssemblyName Classe

Définition

Décrit entièrement l'identité unique d'un assembly.Describes an assembly's unique identity in full.

public ref class AssemblyName sealed : ICloneable, System::Runtime::InteropServices::_AssemblyName, System::Runtime::Serialization::IDeserializationCallback, System::Runtime::Serialization::ISerializable
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public sealed class AssemblyName : ICloneable, System.Runtime.InteropServices._AssemblyName, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
type AssemblyName = class
    interface ICloneable
    interface ISerializable
    interface IDeserializationCallback
    interface _AssemblyName
Public NotInheritable Class AssemblyName
Implements _AssemblyName, ICloneable, IDeserializationCallback, ISerializable
Héritage
AssemblyName
Attributs
Implémente

Exemples

Cet exemple montre comment utiliser diverses classes de réflexion pour analyser les métadonnées contenues dans un assembly.This example shows how to use various reflection classes to analyze the metadata contained in an assembly.

using namespace System;
using namespace System::Reflection;

static void Display(Int32 indent, String^ format, ... array<Object^>^param) 
{
    Console::Write("{0}", gcnew String (' ', indent));
    Console::WriteLine(format, param);
}
    
// Displays the custom attributes applied to the specified member.
static void DisplayAttributes(Int32 indent, MemberInfo^ mi)
{
    // Get the set of custom attributes; if none exist, just return.
    array<Object^>^attrs = mi->GetCustomAttributes(false);
        
    if (attrs->Length==0)
    {
        return;          
    }
        
    // Display the custom attributes applied to this member.
    Display(indent+1, "Attributes:");
    for each ( Object^ o in attrs )
    {
        Display(indent*2, "{0}", o);
    }				
}

void main()
{
    try
    {
        // This variable holds the amount of indenting that 
        // should be used when displaying each line of information.
        Int32 indent = 0; 
        // Display information about the EXE assembly.
        Assembly^ a = System::Reflection::Assembly::GetExecutingAssembly();
        
        Display(indent, "Assembly identity={0}", gcnew array<Object^> {a->FullName});
        Display(indent+1, "Codebase={0}", gcnew array<Object^> {a->CodeBase});

        // Display the set of assemblies our assemblies reference.
  
        Display(indent, "Referenced assemblies:"); 

        for each ( AssemblyName^ an in a->GetReferencedAssemblies() )
        {
            Display(indent + 1, "Name={0}, Version={1}, Culture={2}, PublicKey token={3}", gcnew array<Object^> {an->Name, an->Version, an->CultureInfo, (BitConverter::ToString(an->GetPublicKeyToken()))});
        }
        Display(indent, "");  
        // Display information about each assembly loading into this AppDomain. 
        for each ( Assembly^ b in AppDomain::CurrentDomain->GetAssemblies()) 
        {
            Display(indent, "Assembly: {0}", gcnew array<Object^> {b});
            // Display information about each module of this assembly.
 
            for each ( Module^ m in b->GetModules(true) ) 
            {
                Display(indent+1, "Module: {0}", gcnew array<Object^> {m->Name});
            }
            // Display information about each type exported from this assembly.
           
            indent += 1; 
            for each ( Type^ t in b->GetExportedTypes() ) 
            {
                Display(0, "");  
                Display(indent, "Type: {0}", gcnew array<Object^> {t}); 

                // For each type, show its members & their custom attributes.
           
                indent += 1; 
                for each (MemberInfo^ mi in t->GetMembers() )
                {
                    Display(indent, "Member: {0}", gcnew array<Object^> {mi->Name}); 
                    DisplayAttributes(indent, mi);

                    // If the member is a method, display information about its parameters.         
                    if (mi->MemberType==MemberTypes::Method) 
                    {
                    
                        for each ( ParameterInfo^ pi in (((MethodInfo^) mi)->GetParameters()))
                        {
                            Display(indent+1, "Parameter: Type={0}, Name={1}", gcnew array<Object^> {pi->ParameterType, pi->Name}); 
                        }
                    }

                    // If the member is a property, display information about the property's accessor methods.
                    if (mi->MemberType==MemberTypes::Property) 
                    {
                        for each ( MethodInfo^ am in (((PropertyInfo^) mi)->GetAccessors()) )
                        {
                            Display(indent+1, "Accessor method: {0}", gcnew array<Object^> {am});
                        }
                    }
                }
                // Display a formatted string indented by the specified amount.               
                indent -= 1;
            }
            indent -= 1;
        }
    }
    catch (Exception^ e)
    {
        Console::WriteLine(e->Message);
    }
}

// The output shown below is abbreviated.
//
//Assembly identity=Reflection, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
//  Codebase=file:///C:/Reflection.exe
//Referenced assemblies:
//  Name=mscorlib, Version=1.0.5000.0, Culture=, PublicKey token=B7-7A-5C-56-19-34-E0-89
//  Name=Microsoft.VisualBasic, Version=7.0.5000.0, Culture=, PublicKey token=B0-3F-5F-7F-11-D5-0A-3A
//
//Assembly: mscorlib, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
//  Module: mscorlib.dll
//  Module: prc.nlp
//  Module: prcp.nlp
//  Module: ksc.nlp
//  Module: ctype.nlp
//  Module: xjis.nlp
//  Module: bopomofo.nlp
//  Module: culture.nlp
//  Module: region.nlp
//  Module: sortkey.nlp
//  Module: charinfo.nlp
//  Module: big5.nlp
//  Module: sorttbls.nlp
//  Module: l_intl.nlp
//  Module: l_except.nlp
//
//  Type: System.Object
//    Member: GetHashCode
//    Member: Equals
//      Parameter: Type=System.Object, Name=obj
//    Member: ToString
//    Member: Equals
//      Parameter: Type=System.Object, Name=objA
//      Parameter: Type=System.Object, Name=objB
//    Member: ReferenceEquals
//      Parameter: Type=System.Object, Name=objA
//      Parameter: Type=System.Object, Name=objB
//    Member: GetType
//    Member: .ctor
//
//  Type: System.ICloneable
//    Member: Clone
//
//  Type: System.Collections.IEnumerable
//    Member: GetEnumerator
//      Attributes:
//        System.Runtime.InteropServices.DispIdAttribute
//
//  Type: System.Collections.ICollection
//    Member: get_IsSynchronized
//    Member: get_SyncRoot
//    Member: get_Count
//    Member: CopyTo
//      Parameter: Type=System.Array, Name=array
//      Parameter: Type=System.Int32, Name=index
//    Member: Count
//      Accessor method: Int32 get_Count()
//    Member: SyncRoot
//      Accessor method: System.Object get_SyncRoot()
//    Member: IsSynchronized
//      Accessor method: Boolean get_IsSynchronized()
//
using System;
using System.Reflection;

class Module1
{
    public static void Main()
    {
        // This variable holds the amount of indenting that 
        // should be used when displaying each line of information.
        Int32 indent = 0;
        // Display information about the EXE assembly.
        Assembly a = typeof(Module1).Assembly;
        Display(indent, "Assembly identity={0}", a.FullName);
        Display(indent+1, "Codebase={0}", a.CodeBase);

        // Display the set of assemblies our assemblies reference.
      
        Display(indent, "Referenced assemblies:");
        foreach (AssemblyName an in a.GetReferencedAssemblies() )
        {
             Display(indent + 1, "Name={0}, Version={1}, Culture={2}, PublicKey token={3}", an.Name, an.Version, an.CultureInfo.Name, (BitConverter.ToString (an.GetPublicKeyToken())));
        }
        Display(indent, "");
        
        // Display information about each assembly loading into this AppDomain.
        foreach (Assembly b in AppDomain.CurrentDomain.GetAssemblies())
        {
            Display(indent, "Assembly: {0}", b);

            // Display information about each module of this assembly.
            foreach ( Module m in b.GetModules(true) )
            {
                Display(indent+1, "Module: {0}", m.Name);
            }

            // Display information about each type exported from this assembly.
           
            indent += 1;
            foreach ( Type t in b.GetExportedTypes() )
            {
                Display(0, "");
                Display(indent, "Type: {0}", t);

                // For each type, show its members & their custom attributes.
           
                indent += 1;
                foreach (MemberInfo mi in t.GetMembers() )
                {
                    Display(indent, "Member: {0}", mi.Name);
                    DisplayAttributes(indent, mi);

                    // If the member is a method, display information about its parameters.
                    
                    if (mi.MemberType==MemberTypes.Method)
                    {
                        foreach ( ParameterInfo pi in ((MethodInfo) mi).GetParameters() )
                        {
                            Display(indent+1, "Parameter: Type={0}, Name={1}", pi.ParameterType, pi.Name);
                        }
                    }

                    // If the member is a property, display information about the property's accessor methods.
                    if (mi.MemberType==MemberTypes.Property)
                    {
                        foreach ( MethodInfo am in ((PropertyInfo) mi).GetAccessors() )
                        {
                            Display(indent+1, "Accessor method: {0}", am);
                        }
                    }
                }
                indent -= 1;
            }
            indent -= 1;
        }
    }

    // Displays the custom attributes applied to the specified member.
    public static void DisplayAttributes(Int32 indent, MemberInfo mi)
    {
        // Get the set of custom attributes; if none exist, just return.
        object[] attrs = mi.GetCustomAttributes(false);
        if (attrs.Length==0) {return;}

        // Display the custom attributes applied to this member.
        Display(indent+1, "Attributes:");
        foreach ( object o in attrs )
        {
            Display(indent+2, "{0}", o.ToString());
        }
    }

    // Display a formatted string indented by the specified amount.
    public static void Display(Int32 indent, string format, params object[] param) 

    {
        Console.Write(new string(' ', indent*2));
        Console.WriteLine(format, param);
    }
}

//The output shown below is abbreviated.
//
//Assembly identity=ReflectionCS, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
//  Codebase=file:///C:/Documents and Settings/test/My Documents/Visual Studio 2005/Projects/Reflection/Reflection/obj/Debug/Reflection.exe
//Referenced assemblies:
//  Name=mscorlib, Version=2.0.0.0, Culture=, PublicKey token=B7-7A-5C-56-19-34-E0-89
//
//Assembly: mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
//  Module: mscorlib.dll
//  Module: mscorlib.dll
//  Module: mscorlib.dll
//  Module: mscorlib.dll
//  Module: mscorlib.dll
//  Module: mscorlib.dll
//  Module: mscorlib.dll
//  Module: mscorlib.dll
//  Module: mscorlib.dll
//  Module: mscorlib.dll
//  Module: mscorlib.dll
//  Module: mscorlib.dll
//  Module: mscorlib.dll
//  Module: mscorlib.dll
//
//  Type: System.Object
//    Member: GetType
//    Member: ToString
//    Member: Equals
//      Parameter: Type=System.Object, Name=obj
//    Member: Equals
//      Parameter: Type=System.Object, Name=objA
//      Parameter: Type=System.Object, Name=objB
//    Member: ReferenceEquals
//      Attributes:
//        System.Runtime.ConstrainedExecution.ReliabilityContractAttribute
//      Parameter: Type=System.Object, Name=objA
//      Parameter: Type=System.Object, Name=objB
//    Member: GetHashCode
//    Member: .ctor
//      Attributes:
//        System.Runtime.ConstrainedExecution.ReliabilityContractAttribute
//
//  Type: System.ICloneable
//    Member: Clone
//
//  Type: System.Collections.IEnumerable
//    Member: GetEnumerator
//      Attributes:
//        System.Runtime.InteropServices.DispIdAttribute
//
//  Type: System.Collections.ICollection
//    Member: CopyTo
//      Parameter: Type=System.Array, Name=array
//      Parameter: Type=System.Int32, Name=index
//    Member: get_Count
//    Member: get_SyncRoot
//    Member: get_IsSynchronized
//    Member: Count
//      Accessor method: Int32 get_Count()
//    Member: SyncRoot
//      Accessor method: System.Object get_SyncRoot()
//    Member: IsSynchronized
//      Accessor method: Boolean get_IsSynchronized()
//
//  Type: System.Collections.IList
//    Member: get_Item
//      Parameter: Type=System.Int32, Name=index
//    Member: set_Item
//      Parameter: Type=System.Int32, Name=index
//      Parameter: Type=System.Object, Name=value
//    Member: Add
//      Parameter: Type=System.Object, Name=value
//    Member: Contains
//      Parameter: Type=System.Object, Name=value
//    Member: Clear
//    Member: get_IsReadOnly
//    Member: get_IsFixedSize
//    Member: IndexOf
//      Parameter: Type=System.Object, Name=value
//    Member: Insert
//      Parameter: Type=System.Int32, Name=index
//      Parameter: Type=System.Object, Name=value
//    Member: Remove
//      Parameter: Type=System.Object, Name=value
//    Member: RemoveAt
//      Parameter: Type=System.Int32, Name=index
//    Member: Item
//      Accessor method: System.Object get_Item(Int32)
//      Accessor method: Void set_Item(Int32, System.Object)
//    Member: IsReadOnly
//      Accessor method: Boolean get_IsReadOnly()
//    Member: IsFixedSize
//      Accessor method: Boolean get_IsFixedSize()
//
//  Type: System.Array
//    Member: IndexOf
//      Parameter: Type=T[], Name=array
//      Parameter: Type=T, Name=value
//    Member: AsReadOnly
//      Parameter: Type=T[], Name=array
//    Member: Resize
//      Attributes:
//        System.Runtime.ConstrainedExecution.ReliabilityContractAttribute
//      Parameter: Type=T[]&, Name=array
//      Parameter: Type=System.Int32, Name=newSize
//    Member: BinarySearch
//      Attributes:
//        System.Runtime.ConstrainedExecution.ReliabilityContractAttribute
//      Parameter: Type=T[], Name=array
//      Parameter: Type=T, Name=value
//    Member: BinarySearch
//      Attributes:
//        System.Runtime.ConstrainedExecution.ReliabilityContractAttribute
//      Parameter: Type=T[], Name=array
//      Parameter: Type=T, Name=value
//      Parameter: Type=System.Collections.Generic.IComparer`1[T], Name=comparer
Imports System.Reflection

Module Module1
    Sub Main()
        ' This variable holds the amount of indenting that 
        ' should be used when displaying each line of information.
        Dim indent As Int32 = 0
        ' Display information about the EXE assembly.
        Dim a As Assembly = GetType(Module1).Assembly
        Display(indent, "Assembly identity={0}", a.FullName)
        Display(indent + 1, "Codebase={0}", a.CodeBase)

        ' Display the set of assemblies our assemblies reference.
        Dim an As AssemblyName
        Display(indent, "Referenced assemblies:")
        For Each an In a.GetReferencedAssemblies()
            Display(indent + 1, "Name={0}, Version={1}, Culture={2}, PublicKey token={3}", _
                an.Name, an.Version, an.CultureInfo.Name, BitConverter.ToString(an.GetPublicKeyToken))
        Next
        Display(indent, "")

        ' Display information about each assembly loading into this AppDomain.
        For Each a In AppDomain.CurrentDomain.GetAssemblies()
            Display(indent, "Assembly: {0}", a)

            ' Display information about each module of this assembly.
            Dim m As [Module]
            For Each m In a.GetModules(True)
                Display(indent + 1, "Module: {0}", m.Name)
            Next

            ' Display information about each type exported from this assembly.
            Dim t As Type
            indent += 1
            For Each t In a.GetExportedTypes()
                Display(0, "")
                Display(indent, "Type: {0}", t)

                ' For each type, show its members & their custom attributes.
                Dim mi As MemberInfo
                indent += 1
                For Each mi In t.GetMembers()
                    Display(indent, "Member: {0}", mi.Name)
                    DisplayAttributes(indent, mi)

                    ' If the member is a method, display information about its parameters.
                    Dim pi As ParameterInfo
                    If mi.MemberType = MemberTypes.Method Then
                        For Each pi In CType(mi, MethodInfo).GetParameters()
                            Display(indent + 1, "Parameter: Type={0}, Name={1}", pi.ParameterType, pi.Name)
                        Next
                    End If

                    ' If the member is a property, display information about the property's accessor methods.
                    If mi.MemberType = MemberTypes.Property Then
                        Dim am As MethodInfo
                        For Each am In CType(mi, PropertyInfo).GetAccessors()
                            Display(indent + 1, "Accessor method: {0}", am)
                        Next
                    End If
                Next
                indent -= 1
            Next
            indent -= 1
        Next
    End Sub

    ' Displays the custom attributes applied to the specified member.
    Sub DisplayAttributes(ByVal indent As Int32, ByVal mi As MemberInfo)
        ' Get the set of custom attributes; if none exist, just return.
        Dim attrs() As Object = mi.GetCustomAttributes(False)
        If attrs.Length = 0 Then Return

        ' Display the custom attributes applied to this member.
        Display(indent + 1, "Attributes:")
        Dim o As Object
        For Each o In attrs
            Display(indent + 2, "{0}", o.ToString())
        Next
    End Sub

    ' Display a formatted string indented by the specified amount.
    Sub Display(ByVal indent As Int32, ByVal format As String, ByVal ParamArray params() As Object)
        Console.Write(New String(" "c, indent * 2))
        Console.WriteLine(format, params)
    End Sub
End Module

'The output shown below is abbreviated.
'
'Assembly identity=Reflection, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
'  Codebase=file:///C:/Reflection.exe
'Referenced assemblies:
'  Name=mscorlib, Version=1.0.5000.0, Culture=, PublicKey token=B7-7A-5C-56-19-34-E0-89
'  Name=Microsoft.VisualBasic, Version=7.0.5000.0, Culture=, PublicKey token=B0-3F-5F-7F-11-D5-0A-3A
'
'Assembly: mscorlib, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
'  Module: mscorlib.dll
'  Module: prc.nlp
'  Module: prcp.nlp
'  Module: ksc.nlp
'  Module: ctype.nlp
'  Module: xjis.nlp
'  Module: bopomofo.nlp
'  Module: culture.nlp
'  Module: region.nlp
'  Module: sortkey.nlp
'  Module: charinfo.nlp
'  Module: big5.nlp
'  Module: sorttbls.nlp
'  Module: l_intl.nlp
'  Module: l_except.nlp
'
'  Type: System.Object
'    Member: GetHashCode
'    Member: Equals
'      Parameter: Type=System.Object, Name=obj
'    Member: ToString
'    Member: Equals
'      Parameter: Type=System.Object, Name=objA
'      Parameter: Type=System.Object, Name=objB
'    Member: ReferenceEquals
'      Parameter: Type=System.Object, Name=objA
'      Parameter: Type=System.Object, Name=objB
'    Member: GetType
'    Member: .ctor
'
'  Type: System.ICloneable
'    Member: Clone
'
'  Type: System.Collections.IEnumerable
'    Member: GetEnumerator
'      Attributes:
'        System.Runtime.InteropServices.DispIdAttribute
'
'  Type: System.Collections.ICollection
'    Member: get_IsSynchronized
'    Member: get_SyncRoot
'    Member: get_Count
'    Member: CopyTo
'      Parameter: Type=System.Array, Name=array
'      Parameter: Type=System.Int32, Name=index
'    Member: Count
'      Accessor method: Int32 get_Count()
'    Member: SyncRoot
'      Accessor method: System.Object get_SyncRoot()
'    Member: IsSynchronized
'      Accessor method: Boolean get_IsSynchronized()
'

Remarques

L' AssemblyName objet contient des informations sur un assembly, que vous pouvez utiliser pour établir une liaison à cet assembly.The AssemblyName object contains information about an assembly, which you can use to bind to that assembly. L’identité d’un assembly se compose des éléments suivants :An assembly's identity consists of the following:

  • Nom simple.Simple name.

  • Numéro de version.Version number.

  • Paire de clés de chiffrement.Cryptographic key pair.

  • Culture prise en charge.Supported culture.

Le nom simple est généralement le nom de fichier du fichier manifeste sans son extension.The simple name is typically the file name for the manifest file without its extension. La paire de clés comprend une clé publique et une clé privée, utilisées pour créer des signatures de noms forts pour les assemblys.The key pair includes a public and private key, used to create strong-name signatures for assemblies.

Tous les compilateurs qui prennent en charge le common language runtime émettent le nom simple d’une classe imbriquée, et la réflexion construit un nom tronqué lorsqu’il est interrogé, conformément aux conventions suivantes.All compilers that support the common language runtime will emit the simple name of a nested class, and reflection constructs a mangled name when queried, in accordance with the following conventions.

LimiteDelimiter SignificationMeaning
Barre oblique inverse (\)Backslash (\) Caractère d’échappement.Escape character.
Virgule (,)Comma (,) Précède le nom de l’assembly.Precedes the assembly name.
Signe plus (+)Plus sign (+) Précède une classe imbriquée.Precedes a nested class.

Par exemple, le nom qualifié complet d’une classe peut se présenter comme suit :For example, the fully qualified name for a class might look like this:

ContainingClass + NestedClass, MyAssemblyContainingClass+NestedClass,MyAssembly

Un « + + » devient «\\\+\+ » et un « » devient «\».A "++" becomes "\+\+", and a "\" becomes "\\".

Ce nom qualifié peut être persistant et utilisé ultérieurement pour charger Type.This qualified name can be persisted and later used to load the Type. Pour rechercher et charger un Type, utilisez GetType soit avec le nom de type uniquement, soit avec le nom de type qualifié d’assembly.To search for and load a Type, use GetType either with the type name only or with the assembly qualified type name. GetTypeavec le nom de type, recherche Type uniquement dans l’assembly de l’appelant, puis dans l’assembly système.GetType with the type name only will look for the Type in the caller's assembly and then in the System assembly. GetTypeavec le nom de type qualifié d’assembly, Type recherche le dans n’importe quel assembly.GetType with the assembly qualified type name will look for the Type in any assembly.

Un spécifié AssemblyName complet doit avoir le nom, la culture, la clé publique ou le jeton de clé publique, la version principale, la version mineure, le numéro de build et le numéro de révision.A fully specified AssemblyName must have the name, culture, public key or public key token, major version, minor version, build number, and revision number parameters. Les quatre derniers sont empaquetés Version dans le type.The last four are packaged in the Version type.

Pour créer un nom simple, créez un AssemblyName objet à l’aide du constructeur sans paramètre et Namedéfinissez.To create a simple name, create an AssemblyName object using the parameterless constructor and set the Name. Les autres propriétés sont facultatives.The other properties are optional.

Pour créer un nom fort complet, créez un AssemblyName objet à l’aide du constructeur sans paramètre et Name définissez KeyPairet.To create a full strong name, create an AssemblyName object using the parameterless constructor and set the Name and KeyPair. Les autres propriétés sont facultatives.The other properties are optional. Utilisez SetPublicKey etSetPublicKeyToken pour définir la clé publique et le nom fort.Use SetPublicKey and SetPublicKeyToken to set the public key and the strong name. La signature de nom fort utilise toujours SHA1 l’algorithme de hachage.The strong name signing always uses the SHA1 hash algorithm.

Pour vous assurer que les noms sont correctement construits, utilisez les propriétés suivantes :To ensure that the names are constructed correctly, use the following properties:

Vous pouvez également récupérer le nom à l’aide /l de l’option avec Gacutil. exe (outil global assembly cache)You can also get the name by using the /l option with the Gacutil.exe (Global Assembly Cache Tool)

Pour un nom fort partiellement spécifié, créez un AssemblyName objet à l’aide du constructeur sans paramètre et définissez le nom et la clé publique.For a partially specified strong name, create an AssemblyName object using the parameterless constructor and set the name and public key. Un assembly créé à l' AssemblyName aide de ce type peut être signé ultérieurement à l’aide de l’outil Assembly Linker (al. exe).An assembly created using such an AssemblyName can be signed later using the Assembly Linker (Al.exe).

Il est possible de spécifier une clé publique et une KeyPair avec des valeurs incohérentes.It is possible to specify a public key and a KeyPair with inconsistent values. Cela peut être utile dans les scénarios de développement.This can be useful in developer scenarios. Dans ce cas, la clé publique Récupérée avec GetPublicKey spécifie la clé publique correcte, tandis que spécifie les clés publiques et privées utilisées pendant le KeyPair développement.In this case, the public key retrieved with GetPublicKey specifies the correct public key, while the KeyPair specifies the public and private keys used during development. Lorsque le runtime détecte une incompatibilité entre le KeyPair et la clé publique, il recherche dans le registre la clé appropriée qui correspond à la clé publique.When the runtime detects a mismatch between the KeyPair and the public key, it looks up in the registry the correct key that matches the public key.

Le format du nom complet d’un AssemblyName est une chaîne Unicode délimitée par des virgules qui commence par le nom, comme suit :The format of the display name of an AssemblyName is a comma-delimited Unicode string that begins with the name, as follows:

Name <,Culture = CultureInfo> <,Version = Major.Minor.Build.Revision> <, StrongName> <,PublicKeyToken> '\0'

Namenom textuel de l’assembly.Name is the textual name of the assembly. CultureInfoest la culture définie par le format RFC1766.CultureInfo is the RFC1766-format-defined culture. Major, Minor, Build etRevision sont la version principale, la version mineure, le numéro de build et le numéro de révision de l’assembly.Major, Minor, Build, and Revision are the major version, minor version, build number, and revision number of the assembly. StrongNameest l’octet de poids faible 64 encodé en hexadécimal de la valeur de hachage de la clé publique générée à l’aide de l’algorithme de hachage SHA-1 et de la SetPublicKeyclé publique spécifiée par.StrongName is the hexadecimal-encoded low-order 64 bits of the hash value of the public key generated using the SHA-1 hashing algorithm and the public key specified by SetPublicKey. PublicKeyTokenest la clé publique encodée en hexadécimal spécifiée par SetPublicKey.PublicKeyToken is the hexadecimal-encoded public key specified by SetPublicKey.

L’encodage hexadécimal est défini comme la conversion de chaque octet d’un objet binaire en deux caractères hexadécimaux, en progressant du moins à l’octet le plus significatif.Hexadecimal encoding is defined as the conversion of each byte of a binary object to two hexadecimal characters, progressing from least to most significant byte. Des valeurs d’affichage supplémentaires seront ajoutées, le cas échéant.Additional display values will be added as deemed necessary.

Si la clé publique complète est connue, PublicKey peut être substituée à StrongName.If the full public key is known, then PublicKey may be substituted for StrongName.

Notez également que, à Namel’exception de, qui doit venir en premier, l’ordre lexical des paramètres n’a pas d’importance.Also note that except for Name, which must come first, the lexical order of parameters is unimportant. Toutefois, n’importe quelVersionparamètre Culture( StrongName , PublicKeyou) qui n’est pas AssemblyName spécifiquement défini est considéré comme omis, et est alors considéré comme partiel.However, any parameter (Version, Culture, StrongName or PublicKey) not specifically set is considered to be omitted, and the AssemblyName is then considered partial. Lorsque vous spécifiez des informations partielles, les paramètres de nom doivent être spécifiés dans l’ordre décrit ci-dessus.When specifying partial information, Name parameters must be specified in the order described above.

Lorsque vous fournissez un nom complet, la StrongName =null convention PublicKey= null ou indique que la liaison et la correspondance avec un assembly nommé simplement sont requises.When supplying a display name, the convention StrongName =null or PublicKey= null indicates that binding and matching against a simply named assembly is required. En outre, la convention Culture= "" (guillemet double représentant une chaîne vide) indique la correspondance avec la culture par défaut.Additionally, the convention Culture= "" (double quote representing an empty string) indicates matching against the default culture.

L’exemple suivant montre un AssemblyName pour un assembly nommé simplement avec la culture par défaut.The following example shows an AssemblyName for a simply named assembly with default culture.

ExampleAssembly, Culture=""  

L’exemple suivant illustre une référence complète pour un assembly utilisant un nom fort et la culture « en ».The following example shows a fully specified reference for a strongly named assembly with culture "en".

ExampleAssembly, Version=1.0.0.0, Culture=en, PublicKeyToken=a5d015c7d5a0b012  

Constructeurs

AssemblyName()

Initialise une nouvelle instance de la classe AssemblyName.Initializes a new instance of the AssemblyName class.

AssemblyName(String)

Initialise une nouvelle instance de la classe AssemblyName avec le nom d’affichage spécifié.Initializes a new instance of the AssemblyName class with the specified display name.

Propriétés

CodeBase

Obtient ou définit l'emplacement de l'assembly sous forme d'URL.Gets or sets the location of the assembly as a URL.

ContentType

Obtient ou définit une valeur qui indique le type de contenu que l'assembly contient.Gets or sets a value that indicates what type of content the assembly contains.

CultureInfo

Obtient ou définit la culture prise en charge par l'assembly.Gets or sets the culture supported by the assembly.

CultureName

Obtient ou définit le nom de la culture associée à l'assembly.Gets or sets the name of the culture associated with the assembly.

EscapedCodeBase

Obtient l'URI, y compris les caractères d'espacement, qui représente le code base.Gets the URI, including escape characters, that represents the codebase.

Flags

Obtient ou définit les attributs de l'assembly.Gets or sets the attributes of the assembly.

FullName

Obtient le nom complet de l'assembly.Gets the full name of the assembly, also known as the display name.

HashAlgorithm

Obtient ou définit l'algorithme de hachage utilisé par le manifeste d'assembly.Gets or sets the hash algorithm used by the assembly manifest.

KeyPair

Obtient ou définit la paire de clés de chiffrement publique et privée qui est utilisée pour créer une signature de nom fort pour l'assembly.Gets or sets the public and private cryptographic key pair that is used to create a strong name signature for the assembly.

Name

Obtient ou définit le nom simple de l'assembly.Gets or sets the simple name of the assembly. Il s'agit généralement, mais pas nécessairement, du nom de fichier du fichier manifeste d'assembly, sans son extension.This is usually, but not necessarily, the file name of the manifest file of the assembly, minus its extension.

ProcessorArchitecture

Obtient ou définit une valeur qui identifie le processeur et les bits par mot de la plateforme ciblée par un fichier exécutable.Gets or sets a value that identifies the processor and bits-per-word of the platform targeted by an executable.

Version

Obtient ou définit les numéros principal, secondaire, de build et de révision de l'assembly.Gets or sets the major, minor, build, and revision numbers of the assembly.

VersionCompatibility

Obtient ou définit des informations sur la compatibilité de l'assembly avec d'autres assemblys.Gets or sets the information related to the assembly's compatibility with other assemblies.

Méthodes

Clone()

Exécute une copie de cet objet AssemblyName.Makes a copy of this AssemblyName object.

Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
GetAssemblyName(String)

Obtient le AssemblyName d'un fichier donné.Gets the AssemblyName for a given file.

GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetObjectData(SerializationInfo, StreamingContext)

Obtient les informations de sérialisation avec toutes les données nécessaires à la recréation d'une instance de ce AssemblyName.Gets serialization information with all the data needed to recreate an instance of this AssemblyName.

GetPublicKey()

Obtient la clé publique de l'assembly.Gets the public key of the assembly.

GetPublicKeyToken()

Obtient le jeton de clé publique qui correspond aux 8 derniers octets du hachage SHA-1 de la clé publique sous laquelle est signé l'application ou l'assembly.Gets the public key token, which is the last 8 bytes of the SHA-1 hash of the public key under which the application or assembly is signed.

GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
OnDeserialization(Object)

Implémente l’interface ISerializable et est rappelé par l’événement de désérialisation quand la désérialisation est terminée.Implements the ISerializable interface and is called back by the deserialization event when deserialization is complete.

ReferenceMatchesDefinition(AssemblyName, AssemblyName)

Retourne une valeur indiquant si deux noms d'assembly sont identiques.Returns a value indicating whether two assembly names are the same. La comparaison est basée sur les noms d'assembly simples.The comparison is based on the simple assembly names.

SetPublicKey(Byte[])

Définit la clé publique identifiant l'assembly.Sets the public key identifying the assembly.

SetPublicKeyToken(Byte[])

Définit le jeton de clé publique, qui correspond aux 8 derniers octets du hachage SHA-1 de la clé publique sous laquelle est signé l'application ou l'assembly.Sets the public key token, which is the last 8 bytes of the SHA-1 hash of the public key under which the application or assembly is signed.

ToString()

Retourne le nom complet de l'assembly.Returns the full name of the assembly, also known as the display name.

Implémentations d’interfaces explicites

_AssemblyName.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch.Maps a set of names to a corresponding set of dispatch identifiers.

_AssemblyName.GetTypeInfo(UInt32, UInt32, IntPtr)

Récupère les informations de type pour un objet, qui peuvent être utilisées ensuite pour obtenir les informations de type d'une interface.Retrieves the type information for an object, which can then be used to get the type information for an interface.

_AssemblyName.GetTypeInfoCount(UInt32)

Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

_AssemblyName.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fournit l'accès aux propriétés et aux méthodes exposées par un objet.Provides access to properties and methods exposed by an object.

S’applique à

Voir aussi