AssemblyName Classe

Definizione

Descrive in modo completo l'identità univoca di 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
Ereditarietà
AssemblyName
Attributi
Implementazioni

Esempi

In questo esempio viene illustrato come utilizzare varie classi di reflection per analizzare i metadati contenuti in 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()
'

Commenti

L' AssemblyName oggetto contiene informazioni su un assembly, che è possibile utilizzare per eseguire l'associazione a tale assembly.The AssemblyName object contains information about an assembly, which you can use to bind to that assembly. L'identità di un assembly è costituita dagli elementi seguenti:An assembly's identity consists of the following:

  • Nome semplice.Simple name.

  • Numero di versione.Version number.

  • Coppia di chiavi crittografiche.Cryptographic key pair.

  • Impostazioni cultura supportate.Supported culture.

Il nome semplice è in genere il nome file del file manifesto senza estensione.The simple name is typically the file name for the manifest file without its extension. La coppia di chiavi include una chiave pubblica e una chiave privata, usata per creare firme con nome sicuro per gli assembly.The key pair includes a public and private key, used to create strong-name signatures for assemblies.

Tutti i compilatori che supportano il Common Language Runtime genereranno il nome semplice di una classe annidata e la reflection costruirà un nome modificato quando viene eseguita una query, in base alle convenzioni seguenti.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.

DelimitatoreDelimiter SignificatoMeaning
Barra rovesciata (\)Backslash (\) Carattere di escape.Escape character.
Virgola (,)Comma (,) Precede il nome dell'assembly.Precedes the assembly name.
Segno più (+)Plus sign (+) Precede una classe annidata.Precedes a nested class.

Il nome completo di una classe, ad esempio, potrebbe essere simile al seguente:For example, the fully qualified name for a class might look like this:

ContainingClass + NestedClass, MyAssemblyContainingClass+NestedClass,MyAssembly

"+ +"\Diventa "+\+" e\"" diventa "\\".A "++" becomes "\+\+", and a "\" becomes "\\".

Questo nome completo può essere reso permanente e successivamente usato per caricare Type.This qualified name can be persisted and later used to load the Type. Per cercare e caricare un oggetto Type, usare GetType solo con il nome del tipo o con il nome del tipo completo di assembly.To search for and load a Type, use GetType either with the type name only or with the assembly qualified type name. GetTypecon il nome del tipo, solo l'oggetto Type verrà cercato nell'assembly del chiamante e quindi nell'assembly di sistema.GetType with the type name only will look for the Type in the caller's assembly and then in the System assembly. GetTypecon il nome del tipo completo di assembly cercherà Type in qualsiasi assembly.GetType with the assembly qualified type name will look for the Type in any assembly.

Un oggetto completamente AssemblyName specificato deve avere il nome, le impostazioni cultura, la chiave pubblica o il token di chiave pubblica, la versione principale, la versione secondaria, il numero di build e i parametri del numero di revisione.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. Le ultime quattro sono assemblate nel Version tipo.The last four are packaged in the Version type.

Per creare un nome semplice, creare un AssemblyName oggetto usando il costruttore senza parametri e impostare la Nameproprietà.To create a simple name, create an AssemblyName object using the parameterless constructor and set the Name. Le altre proprietà sono facoltative.The other properties are optional.

Per creare un nome sicuro completo, creare un AssemblyName oggetto usando il costruttore senza parametri e Name impostare e KeyPair.To create a full strong name, create an AssemblyName object using the parameterless constructor and set the Name and KeyPair. Le altre proprietà sono facoltative.The other properties are optional. Usare SetPublicKey eSetPublicKeyToken per impostare la chiave pubblica e il nome sicuro.Use SetPublicKey and SetPublicKeyToken to set the public key and the strong name. La firma con nome sicuro utilizza sempre SHA1 l'algoritmo hash.The strong name signing always uses the SHA1 hash algorithm.

Per assicurarsi che i nomi siano costruiti correttamente, utilizzare le proprietà seguenti:To ensure that the names are constructed correctly, use the following properties:

È anche possibile ottenere il nome usando l' /l opzione con gacutil. exe (strumento Global assembly cache)You can also get the name by using the /l option with the Gacutil.exe (Global Assembly Cache Tool)

Per un nome sicuro parzialmente specificato, creare un AssemblyName oggetto usando il costruttore senza parametri e impostare il nome e la chiave pubblica.For a partially specified strong name, create an AssemblyName object using the parameterless constructor and set the name and public key. Un assembly creato con tale un AssemblyName può essere firmato in un secondo momento usando assembly linker (al. exe).An assembly created using such an AssemblyName can be signed later using the Assembly Linker (Al.exe).

È possibile specificare una chiave pubblica e un KeyPair con valori incoerenti.It is possible to specify a public key and a KeyPair with inconsistent values. Questa operazione può essere utile negli scenari di sviluppo.This can be useful in developer scenarios. In questo caso, la chiave pubblica recuperata GetPublicKey con specifica la chiave pubblica corretta, KeyPair mentre specifica le chiavi pubbliche e private utilizzate durante lo sviluppo.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. Quando il runtime rileva una mancata corrispondenza tra KeyPair e la chiave pubblica, Cerca nel registro di sistema la chiave corretta corrispondente alla chiave pubblica.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.

Il formato del nome visualizzato di un oggetto AssemblyName è una stringa Unicode delimitata da virgole che inizia con il nome, come indicato di seguito: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'

Namenome testuale dell'assembly.Name is the textual name of the assembly. CultureInforappresenta le impostazioni cultura definite dal formato RFC1766.CultureInfo is the RFC1766-format-defined culture. Major, Minor, eRevision sono la versione principale, la versione secondaria, il numero di build e il numero di revisione dell'assembly. BuildMajor, Minor, Build, and Revision are the major version, minor version, build number, and revision number of the assembly. StrongNamesono i bit 64 con codifica esadecimale del valore hash della chiave pubblica generata usando l'algoritmo di hash SHA-1 e la chiave pubblica specificata da SetPublicKey.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. PublicKeyTokenchiave pubblica con codifica esadecimale specificata da SetPublicKey.PublicKeyToken is the hexadecimal-encoded public key specified by SetPublicKey.

La codifica esadecimale viene definita come conversione di ogni byte di un oggetto binario in due caratteri esadecimali, procedendo da almeno a un byte più significativo.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. I valori di visualizzazione aggiuntivi verranno aggiunti come ritenuti necessari.Additional display values will be added as deemed necessary.

Se è nota la chiave pubblica completa, è possibile sostituire PublicKey con StrongName.If the full public key is known, then PublicKey may be substituted for StrongName.

Si noti inoltre che, Namead eccezione di, che deve essere innanzitutto, l'ordine lessicale dei parametri non è importante.Also note that except for Name, which must come first, the lexical order of parameters is unimportant. Tuttavia, qualsiasi parametro (Version StrongName , Cultureo PublicKey) non impostato AssemblyName in modo specifico viene considerato omesso e viene considerato parziale.However, any parameter (Version, Culture, StrongName or PublicKey) not specifically set is considered to be omitted, and the AssemblyName is then considered partial. Quando si specificano informazioni parziali, i parametri del nome devono essere specificati nell'ordine descritto in precedenza.When specifying partial information, Name parameters must be specified in the order described above.

Quando si specifica un nome visualizzato, la convenzione StrongName =null o PublicKey= null indica che è richiesta l'associazione e la corrispondenza con un assembly con nome semplice.When supplying a display name, the convention StrongName =null or PublicKey= null indicates that binding and matching against a simply named assembly is required. Inoltre, la convenzione Culture= "" (virgolette doppie che rappresenta una stringa vuota) indica la corrispondenza rispetto alle impostazioni cultura predefinite.Additionally, the convention Culture= "" (double quote representing an empty string) indicates matching against the default culture.

Nell'esempio seguente viene illustrato AssemblyName un oggetto per un assembly con nome semplice con impostazioni cultura predefinite.The following example shows an AssemblyName for a simply named assembly with default culture.

ExampleAssembly, Culture=""  

L'esempio seguente illustra un riferimento completo per un assembly con nome sicuro nelle impostazioni cultura "en" (inglese).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  

Costruttori

AssemblyName()

Inizializza una nuova istanza della classe AssemblyName.Initializes a new instance of the AssemblyName class.

AssemblyName(String)

Inizializza una nuova istanza della classe AssemblyName con il nome visualizzato specificato.Initializes a new instance of the AssemblyName class with the specified display name.

Proprietà

CodeBase

Ottiene o imposta il percorso dell'assembly come URL.Gets or sets the location of the assembly as a URL.

ContentType

Ottiene o imposta un valore che indica il tipo di contenuto dell'assembly.Gets or sets a value that indicates what type of content the assembly contains.

CultureInfo

Ottiene o imposta le impostazioni cultura supportate dall'assembly.Gets or sets the culture supported by the assembly.

CultureName

Ottiene o imposta il nome delle impostazioni di cultura associate all'assembly.Gets or sets the name of the culture associated with the assembly.

EscapedCodeBase

Ottiene l'URI, inclusi i caratteri di escape, che rappresenta la codebase.Gets the URI, including escape characters, that represents the codebase.

Flags

Ottiene o imposta gli attributi dell'assembly.Gets or sets the attributes of the assembly.

FullName

Ottiene il nome completo dell'assembly o nome di visualizzazione.Gets the full name of the assembly, also known as the display name.

HashAlgorithm

Ottiene o imposta l'algoritmo hash utilizzato dal manifesto assembly.Gets or sets the hash algorithm used by the assembly manifest.

KeyPair

Ottiene o imposta la coppia di chiavi crittografiche pubblica e privata che viene utilizzata per creare la firma del nome sicuro per 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

Ottiene o imposta il nome semplice dell'assembly.Gets or sets the simple name of the assembly. Tale nome corrisponde in genere, ma non necessariamente, al nome del file manifesto dell'assembly, meno l'estensione.This is usually, but not necessarily, the file name of the manifest file of the assembly, minus its extension.

ProcessorArchitecture

Ottiene o imposta un valore che identifica il processore e i bit per parola della piattaforma di destinazione di un file eseguibile.Gets or sets a value that identifies the processor and bits-per-word of the platform targeted by an executable.

Version

Ottiene o imposta il numero principale, secondario, di build e di revisione dell'assembly.Gets or sets the major, minor, build, and revision numbers of the assembly.

VersionCompatibility

Ottiene o imposta le informazioni relative alla compatibilità dell'assembly con altri assembly.Gets or sets the information related to the assembly's compatibility with other assemblies.

Metodi

Clone()

Esegue una copia di questo oggetto AssemblyName.Makes a copy of this AssemblyName object.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
GetAssemblyName(String)

Ottiene l'oggetto AssemblyName per un dato file.Gets the AssemblyName for a given file.

GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetObjectData(SerializationInfo, StreamingContext)

Ottiene le informazioni di serializzazione con tutti i dati necessari per creare una nuova istanza di AssemblyName.Gets serialization information with all the data needed to recreate an instance of this AssemblyName.

GetPublicKey()

Ottiene la chiave pubblica dell'assembly.Gets the public key of the assembly.

GetPublicKeyToken()

Ottiene il token di chiave pubblica, rappresentato dagli ultimi 8 byte dell'algoritmo hash SHA-1 della chiave pubblica in cui viene eseguita la firma dell'applicazione o dell'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()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
OnDeserialization(Object)

Implementa l'interfaccia ISerializable e viene richiamato dall'evento di deserializzazione al termine della deserializzazione.Implements the ISerializable interface and is called back by the deserialization event when deserialization is complete.

ReferenceMatchesDefinition(AssemblyName, AssemblyName)

Restituisce un valore che indica se due nomi di assembly sono uguali.Returns a value indicating whether two assembly names are the same. Il confronto è basato sui nomi di assembly semplici.The comparison is based on the simple assembly names.

SetPublicKey(Byte[])

Imposta la chiave pubblica che identifica l'assembly.Sets the public key identifying the assembly.

SetPublicKeyToken(Byte[])

Imposta il token di chiave pubblica, rappresentato dagli ultimi 8 byte dell'algoritmo hash SHA-1 della chiave pubblica in cui viene eseguita la firma dell'applicazione o dell'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()

Restituisce il nome completo dell'assembly, noto anche come nome visualizzato.Returns the full name of the assembly, also known as the display name.

Implementazioni dell'interfaccia esplicita

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

Esegue il mapping di un set di nomi a un set corrispondente di ID dispatch.Maps a set of names to a corresponding set of dispatch identifiers.

_AssemblyName.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera le informazioni sul tipo relative a un oggetto che può quindi essere usato per ottenere informazioni sul tipo relative a un'interfaccia.Retrieves the type information for an object, which can then be used to get the type information for an interface.

_AssemblyName.GetTypeInfoCount(UInt32)

Recupera il numero delle interfacce di informazioni sul tipo fornite da un oggetto (0 o 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)

Fornisce l'accesso a proprietà e metodi esposti da un oggetto.Provides access to properties and methods exposed by an object.

Si applica a

Vedi anche