Export (0) Print
Expand All

AssemblyName Class

Describes an assembly's unique identity in full.

System.Object
  System.Reflection.AssemblyName

Namespace:  System.Reflection
Assembly:  mscorlib (in mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
[ClassInterfaceAttribute(ClassInterfaceType.None)]
public sealed class AssemblyName : _AssemblyName, 
	ICloneable, ISerializable, IDeserializationCallback

The AssemblyName type exposes the following members.

  NameDescription
Public methodSupported by the XNA FrameworkSupported by Portable Class LibrarySupported in .NET for Windows Store appsAssemblyName()Initializes a new instance of the AssemblyName class.
Public methodSupported by Portable Class LibrarySupported in .NET for Windows Store appsAssemblyName(String)Initializes a new instance of the AssemblyName class with the specified display name.
Top

  NameDescription
Public propertySupported by the XNA FrameworkCodeBaseGets or sets the location of the assembly as a URL.
Public propertySupported in .NET for Windows Store appsContentTypeGets or sets a value that indicates what type of content the assembly contains.
Public propertySupported by the XNA FrameworkSupported by Portable Class LibraryCultureInfoGets or sets the culture supported by the assembly.
Public propertySupported in .NET for Windows Store appsCultureNameGets or sets the name of the culture associated with the assembly.
Public propertyEscapedCodeBaseGets the URI, including escape characters, that represents the codebase.
Public propertySupported by the XNA FrameworkSupported by Portable Class LibrarySupported in .NET for Windows Store appsFlagsGets or sets the attributes of the assembly.
Public propertySupported by the XNA FrameworkSupported by Portable Class LibrarySupported in .NET for Windows Store appsFullNameGets the full name of the assembly, also known as the display name.
Public propertySupported by the XNA FrameworkHashAlgorithmGets or sets the hash algorithm used by the assembly manifest.
Public propertyKeyPairGets or sets the public and private cryptographic key pair that is used to create a strong name signature for the assembly.
Public propertySupported by the XNA FrameworkSupported by Portable Class LibrarySupported in .NET for Windows Store appsNameGets or sets the simple name of the assembly. This is usually, but not necessarily, the file name of the manifest file of the assembly, minus its extension.
Public propertyProcessorArchitectureGets or sets a value that identifies the processor and bits-per-word of the platform targeted by an executable.
Public propertySupported by the XNA FrameworkSupported by Portable Class LibrarySupported in .NET for Windows Store appsVersionGets or sets the major, minor, build, and revision numbers of the assembly.
Public propertySupported by the XNA FrameworkVersionCompatibilityGets or sets the information related to the assembly's compatibility with other assemblies.
Top

  NameDescription
Public methodSupported by the XNA FrameworkCloneMakes a copy of this AssemblyName object.
Public methodSupported by the XNA FrameworkSupported by Portable Class LibrarySupported in .NET for Windows Store appsEquals(Object)Determines whether the specified object is equal to the current object. (Inherited from Object.)
Public methodStatic memberGetAssemblyNameGets the AssemblyName for a given file.
Public methodSupported by the XNA FrameworkSupported by Portable Class LibrarySupported in .NET for Windows Store appsGetHashCodeServes as the default hash function. (Inherited from Object.)
Public methodGetObjectDataGets serialization information with all the data needed to recreate an instance of this AssemblyName.
Public methodSupported by the XNA FrameworkSupported by Portable Class LibrarySupported in .NET for Windows Store appsGetPublicKeyGets the public key of the assembly.
Public methodSupported by the XNA FrameworkSupported by Portable Class LibrarySupported in .NET for Windows Store appsGetPublicKeyTokenGets 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.
Public methodSupported by the XNA FrameworkSupported by Portable Class LibrarySupported in .NET for Windows Store appsGetTypeGets the Type of the current instance. (Inherited from Object.)
Public methodOnDeserializationImplements the ISerializable interface and is called back by the deserialization event when deserialization is complete.
Public methodStatic memberReferenceMatchesDefinitionReturns a value indicating whether two assembly names are the same. The comparison is based on the simple assembly names.
Public methodSupported by the XNA FrameworkSupported by Portable Class LibrarySupported in .NET for Windows Store appsSetPublicKeySets the public key identifying the assembly.
Public methodSupported by the XNA FrameworkSupported by Portable Class LibrarySupported in .NET for Windows Store appsSetPublicKeyTokenSets 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.
Public methodSupported by the XNA FrameworkSupported by Portable Class LibrarySupported in .NET for Windows Store appsToStringReturns the full name of the assembly, also known as the display name. (Overrides Object.ToString().)
Top

  NameDescription
Explicit interface implemetationPrivate method_AssemblyName.GetIDsOfNamesMaps a set of names to a corresponding set of dispatch identifiers.
Explicit interface implemetationPrivate method_AssemblyName.GetTypeInfoRetrieves the type information for an object, which can then be used to get the type information for an interface.
Explicit interface implemetationPrivate method_AssemblyName.GetTypeInfoCountRetrieves the number of type information interfaces that an object provides (either 0 or 1).
Explicit interface implemetationPrivate method_AssemblyName.InvokeProvides access to properties and methods exposed by an object.
Top

The AssemblyName object contains information about an assembly, which you can use to bind to that assembly. An assembly's identity consists of the following:

  • Simple name.

  • Version number.

  • Cryptographic key pair.

  • Supported culture.

The simple name is typically the file name for the manifest file without its extension. The key pair includes a public and private key, used to create strong-name signatures for assemblies.

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.

Delimiter

Meaning

Backslash (\)

Escape character.

Comma (,)

Precedes the assembly name.

Plus sign (+)

Precedes a nested class.

For example, the fully qualified name for a class might look like this:

ContainingClass+NestedClass,MyAssembly

A "++" becomes "\+\+", and a "\" becomes "\\".

This qualified name can be persisted and later used to load the Type. To search for and load a Type, use GetType either with the type name only or with the assembly qualified type name. GetType with the type name only will look for the Type in the caller's assembly and then in the System assembly. GetType with the assembly qualified type name will look for the Type in any assembly.

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. The last four are packaged in the Version type.

To create a simple name, create an AssemblyName object using the default constructor and set the Name. The other properties are optional.

To create a full strong name, create an AssemblyName object using the default constructor and set the Name and KeyPair. The other properties are optional. Use SetPublicKey and SetPublicKeyToken to set the public key and the strong name. The strong name signing always uses the SHA1 hash algorithm.

To ensure that the names are constructed correctly, use the following properties:

You can also get the name by using the /l option with the Gacutil.exe (Global Assembly Cache Tool)

For a partially specified strong name, create an AssemblyName object using the default constructor and set the name and public key. An assembly created using such an AssemblyName can be signed later using the Assembly Linker (Al.exe).

It is possible to specify a public key and a KeyPair with inconsistent values. This can be useful in developer scenarios. 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. 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.

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'

Name is the textual name of the assembly. CultureInfo is the RFC1766-format-defined culture. Major, Minor, Build, and Revision are the major version, minor version, build number, and revision number of the assembly. 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. PublicKeyToken is the hexadecimal-encoded public key specified by SetPublicKey.

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. Additional display values will be added as deemed necessary.

If the full public key is known, then PublicKey may be substituted for StrongName.

Also note that except for Name, which must come first, the lexical order of parameters is unimportant. However, any parameter (Version, Culture, StrongName or PublicKey) not specifically set is considered to be omitted, and the AssemblyName is then considered partial. When specifying partial information, Name parameters must be specified in the order described above.

When supplying a display name, the convention StrongName =null or PublicKey= null indicates that binding and matching against a simply named assembly is required. Additionally, the convention Culture= "" (double quote representing an empty string) indicates matching against the default culture.

The following example shows an AssemblyName for a simply named assembly with default culture.

ExampleAssembly, Culture=""

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

This example shows how to use various reflection classes to analyze the metadata contained in an assembly.

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

.NET Framework

Supported in: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Supported in: 4, 3.5 SP1

Portable Class Library

Supported in: Portable Class Library

.NET for Windows Store apps

Supported in: Windows 8

.NET for Windows Phone apps

Supported in: Windows Phone 8.1, Windows Phone Silverlight 8.1, Windows Phone Silverlight 8

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core Role not supported), Windows Server 2008 R2 (Server Core Role supported with SP1 or later; Itanium not supported)

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.

Any public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.
Show:
© 2014 Microsoft