Type.AssemblyQualifiedName Type.AssemblyQualifiedName Type.AssemblyQualifiedName Type.AssemblyQualifiedName Property

Definición

Obtiene el nombre calificado con el ensamblado del tipo, que incluye el nombre del ensamblado a partir del cual se ha cargado el objeto Type.Gets the assembly-qualified name of the type, which includes the name of the assembly from which this Type object was loaded.

public:
 abstract property System::String ^ AssemblyQualifiedName { System::String ^ get(); };
public abstract string AssemblyQualifiedName { get; }
member this.AssemblyQualifiedName : string
Public MustOverride ReadOnly Property AssemblyQualifiedName As String

Valor de propiedad

Nombre calificado con el ensamblado de Type, que incluye el nombre del ensamblado a partir del cual se ha cargado Type, o null si la instancia actual representa un parámetro de tipo genérico.The assembly-qualified name of the Type, which includes the name of the assembly from which the Type was loaded, or null if the current instance represents a generic type parameter.

Implementaciones

Ejemplos

En el ejemplo siguiente se muestra el nombre de ensamblado asociado a la clase y el nombre completo del tipo.The following example displays the assembly name associated with the class and the fully qualified name of the type.

using namespace System;
using namespace System::Reflection;
int main()
{
   Type^ objType = System::Array::typeid;
   
   // Print the full assembly name.
   Console::WriteLine( "Full assembly name: {0}.", objType->Assembly->FullName );
   
   // Print the qualified assembly name.
   Console::WriteLine( "Qualified assembly name: {0}.", objType->AssemblyQualifiedName );
}
// The example displays the following output if run under the .NET Framework 4.5:
//    Full assembly name:
//       mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089.
//    Qualified assembly name:
//       System.Array, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089.
using System;

class MyAssemblyClass
{
    public static void Main()
    {
        Type objType = typeof(Array);

        // Print the assembly full name.
        Console.WriteLine($"Assembly full name:\n   {objType.Assembly.FullName}.");

        // Print the assembly qualified name.
        Console.WriteLine($"Assembly qualified name:\n   {objType.AssemblyQualifiedName}.");
    }
}
// The example displays the following output if run under the .NET Framework 4.5:
//    Assembly full name:
//       mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089.
//    Assembly qualified name:
//       System.Array, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089.
Class Example
    Public Shared Sub Main()
        Dim objType As Type = GetType(Array)

        ' Display the assembly full name.
        Console.WriteLine($"Assembly full name:{vbCrLf}   {objType.Assembly.FullName}.")

        ' Display the assembly qualified name.
        Console.WriteLine($"Assembly qualified name:{vbCrLf}   {objType.AssemblyQualifiedName}.")
    End Sub
End Class
' The example displays the following output if run under the .NET Framework 4.5:
'    Assembly full name:
'       mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089.
'    Assembly qualified name:
'       System.Array, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089.

En el ejemplo siguiente se comparan las cadenas ToString devueltas Namepor el método AssemblyQualifiedName y las propiedades, FullNamey.The following example compares the strings returned by the ToString method and the Name, FullName, and AssemblyQualifiedName properties.

using System;
using System.Collections.Generic;
using System.Globalization;

public class Example
{
    public static void Main()
    {
        Type t = typeof(String);
        ShowTypeInfo(t);

        t = typeof(List<>);
        ShowTypeInfo(t);

        var list = new List<String>();
        t = list.GetType();
        ShowTypeInfo(t);

        Object v = 12;
        t = v.GetType();
        ShowTypeInfo(t);

        t = typeof(IFormatProvider);
        ShowTypeInfo(t);

        IFormatProvider ifmt = NumberFormatInfo.CurrentInfo;
        t = ifmt.GetType();
        ShowTypeInfo(t);
    }

    private static void ShowTypeInfo(Type t)
    {
        Console.WriteLine($"Name: {t.Name}");
        Console.WriteLine($"Full Name: {t.FullName}");
        Console.WriteLine($"ToString:  {t}");
        Console.WriteLine($"Assembly Qualified Name: {t.AssemblyQualifiedName}");
        Console.WriteLine();
    }
}
// The example displays output like the following:
//    Name: String
//    Full Name: System.String
//    ToString:  System.String
//    Assembly Qualified Name: System.String, mscorlib, Version=4.0.0.0, Culture=neutr
//    al, PublicKeyToken=b77a5c561934e089
//
//    Name: List`1
//    Full Name: System.Collections.Generic.List`1
//    ToString:  System.Collections.Generic.List`1[T]
//    Assembly Qualified Name: System.Collections.Generic.List`1, mscorlib, Version=4.
//    0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
//
//    Name: List`1
//    Full Name: System.Collections.Generic.List`1[[System.String, mscorlib, Version=4
//    .0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]
//    ToString:  System.Collections.Generic.List`1[System.String]
//    Assembly Qualified Name: System.Collections.Generic.List`1[[System.String, mscor
//    lib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], mscorl
//    ib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
//
//    Name: Int32
//    Full Name: System.Int32
//    ToString:  System.Int32
//    Assembly Qualified Name: System.Int32, mscorlib, Version=4.0.0.0, Culture=neutra
//    l, PublicKeyToken=b77a5c561934e089
//
//    Name: IFormatProvider
//    Full Name: System.IFormatProvider
//    ToString:  System.IFormatProvider
//    Assembly Qualified Name: System.IFormatProvider, mscorlib, Version=4.0.0.0, Cult
//    ure=neutral, PublicKeyToken=b77a5c561934e089
//
//    Name: NumberFormatInfo
//    Full Name: System.Globalization.NumberFormatInfo
//    ToString:  System.Globalization.NumberFormatInfo
//    Assembly Qualified Name: System.Globalization.NumberFormatInfo, mscorlib, Versio
//    n=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
Imports System.Collections.Generic
Imports System.Globalization

Module Example
    Public Sub Main()
        Dim t As Type = GetType(String)
        ShowTypeInfo(t)

        t = GetType(List(Of))
        ShowTypeInfo(t)

        Dim list As New List(Of String)()
        t = list.GetType()
        ShowTypeInfo(t)

        Dim v As Object = 12
        t = v.GetType()
        ShowTypeInfo(t)

        t = GetType(IFormatProvider)
        ShowTypeInfo(t)

        Dim ifmt As IFormatProvider = NumberFormatInfo.CurrentInfo
        t = ifmt.GetType()
        ShowTypeInfo(t)
    End Sub

    Private Sub ShowTypeInfo(t As Type)
        Console.WriteLine($"Name: {t.Name}")
        Console.WriteLine($"Full Name: {t.FullName}")
        Console.WriteLine($"ToString:  {t}")
        Console.WriteLine($"Assembly Qualified Name: {t.AssemblyQualifiedName}")
        Console.WriteLine()
    End Sub
End Module
' The example displays output like the following:
'    Name: String
'    Full Name: System.String
'    ToString:  System.String
'    Assembly Qualified Name: System.String, mscorlib, Version=4.0.0.0, Culture=neutr
'    al, PublicKeyToken=b77a5c561934e089
'
'    Name: List`1
'    Full Name: System.Collections.Generic.List`1
'    ToString:  System.Collections.Generic.List`1[T]
'    Assembly Qualified Name: System.Collections.Generic.List`1, mscorlib, Version=4.
'    0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
'
'    Name: List`1
'    Full Name: System.Collections.Generic.List`1[[System.String, mscorlib, Version=4
'    .0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]
'    ToString:  System.Collections.Generic.List`1[System.String]
'    Assembly Qualified Name: System.Collections.Generic.List`1[[System.String, mscor
'    lib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], mscorl
'    ib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
'
'    Name: Int32
'    Full Name: System.Int32
'    ToString:  System.Int32
'    Assembly Qualified Name: System.Int32, mscorlib, Version=4.0.0.0, Culture=neutra
'    l, PublicKeyToken=b77a5c561934e089
'
'    Name: IFormatProvider
'    Full Name: System.IFormatProvider
'    ToString:  System.IFormatProvider
'    Assembly Qualified Name: System.IFormatProvider, mscorlib, Version=4.0.0.0, Cult
'    ure=neutral, PublicKeyToken=b77a5c561934e089
'
'    Name: NumberFormatInfo
'    Full Name: System.Globalization.NumberFormatInfo
'    ToString:  System.Globalization.NumberFormatInfo
'    Assembly Qualified Name: System.Globalization.NumberFormatInfo, mscorlib, Versio
'    n=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089

Comentarios

El nombre calificado con el ensamblado de un tipo consta del nombre del tipo, incluido su espacio de nombres, seguido de una coma, seguido del nombre para mostrar del ensamblado.The assembly-qualified name of a type consists of the type name, including its namespace, followed by a comma, followed by the display name of the assembly. El nombre para mostrar de un ensamblado se obtiene Assembly.FullName utilizando la propiedad.The display name of an assembly is obtained using the Assembly.FullName property.

Nota

En la versión .NET Framework 2,0, se agrega la arquitectura de procesador a la identidad del ensamblado y se puede especificar como parte de las cadenas de nombre de ensamblado.In the .NET Framework version 2.0, processor architecture is added to assembly identity, and can be specified as part of assembly name strings. Por ejemplo, "ProcessorArchitecture = MSIL".For example, "ProcessorArchitecture=msil". Sin embargo, no se incluye en la cadena devuelta por AssemblyQualifiedName la propiedad, por motivos de compatibilidad.However, it is not included in the string returned by the AssemblyQualifiedName property, for compatibility reasons. Vea AssemblyName.ProcessorArchitecture.See AssemblyName.ProcessorArchitecture.

Todos los compiladores que admiten la Common Language Runtime emiten el nombre simple de una clase anidada y la reflexión construye un nombre alterado cuando se realiza una consulta, de acuerdo con las convenciones siguientes.All compilers that support the common language runtime emit the simple name of a nested class, and reflection constructs a mangled name when queried, in accordance with the following conventions.

DelimitadorDelimiter SignificadoMeaning
Barra diagonal inversa (\)Backslash (\) Carácter de escape.Escape character.
Coma (,)Comma (,) Precede al nombre del ensamblado.Precedes the Assembly name.
Signo más (+)Plus sign (+) Precede a una clase anidada.Precedes a nested class.
Punto (.)Period (.) Denota los identificadores de espacio de nombres.Denotes namespace identifiers.
Corchetes ([])Brackets ([]) Después de un nombre de tipo, denota una matriz de ese tipo.After a type name, denotes an array of that type.

O bien-or-

Para un tipo genérico, incluye la lista de argumentos de tipo genérico.For a generic type, encloses the generic type argument list.

o bien-or-

Dentro de una lista de argumentos de tipo, incluye un tipo calificado con el ensamblado.Within a type argument list, encloses an assembly-qualified type.

Por ejemplo, el nombre calificado con el ensamblado de una clase podría tener el siguiente aspecto:For example, the assembly-qualified name for a class might look like this:

TopNamespace.SubNameSpace.ContainingClass+NestedClass, MyAssembly, Version=1.3.0.0, Culture=neutral, PublicKeyToken=b17a5c561934e089  

Si el espacio de nombres contiene un signo más, por ejemplo, el espacio de nombres. sub +, el signo más (+) estará precedido por un carácter\de escape () para evitar que se interprete como un separador de anidamiento.If the namespace contained a plus sign, for example TopNamespace.Sub+Namespace, then the plus sign (+) would be preceded by an escape character (\) to prevent it from being interpreted as a nesting separator. La reflexión emitiría esta cadena de la siguiente manera:Reflection would emit this string as follows:

TopNamespace.Sub\+Namespace.ContainingClass+NestedClass, MyAssembly, Version=1.3.0.0, Culture=neutral, PublicKeyToken=b17a5c561934e089   

Un "+ +" se convierte\en "\+\+" y "\" se convierte en "\".A "++" becomes "\+\+", and a "\" becomes "\\".

Este nombre completo puede conservarse y, posteriormente, usarse para Typecargar.This qualified name can be persisted and later used to load the Type. Para buscar y cargar un Type, use GetType con el nombre de tipo solamente o con el nombre de tipo calificado con el ensamblado.To search for and load a Type, use GetType either with the type name only or with the assembly qualified type name. GetTypecon el nombre de tipo solo Type buscará en el ensamblado del llamador y, a continuación, en el ensamblado del sistema.GetType with the type name only will look for the Type in the caller's assembly and then in the System assembly. GetTypecon el nombre de tipo calificado con el ensamblado Type , buscará en cualquier ensamblado.GetType with the assembly qualified type name will look for the Type in any assembly.

Los nombres de tipo pueden incluir caracteres finales que denotan información adicional sobre el tipo, como, por ejemplo, si el tipo es un tipo de referencia, un tipo de puntero o un tipo de matriz.Type names may include trailing characters that denote additional information about the type, such as whether the type is a reference type, a pointer type or an array type. Para recuperar el nombre de tipo sin estos caracteres finales, use t.GetElementType().ToString(), donde t es el tipo.To retrieve the type name without these trailing characters, use t.GetElementType().ToString(), where t is the type.

Los espacios son relevantes en todos los componentes de nombre de tipo excepto en el nombre de ensamblado.Spaces are relevant in all type name components except the assembly name. En el nombre del ensamblado, los espacios antes del separador "," son relevantes, pero los espacios después del separador "," se omiten.In the assembly name, spaces before the ',' separator are relevant, but spaces after the ',' separator are ignored.

Los argumentos genéricos de tipos genéricos se califican por nombre de ensamblado.Generic arguments of generic types are themselves qualified by assembly name. Por ejemplo, en el nombre de tipo calificado con el MyGenericClass<int> ensamblado para (MyGenericClass(Of Integer) en int Visual Basic), se expande al nombre de tipo calificado Int32con el ensamblado para.For example, in the assembly-qualified type name for MyGenericClass<int> (MyGenericClass(Of Integer) in Visual Basic), int is expanded to the assembly-qualified type name for Int32.

Si el objeto Type actual representa un parámetro genérico, esta propiedad devuelve null.If the current Type object represents a generic parameter, this property returns null.

Se aplica a

Consulte también: