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

Definizione

Ottiene il nome qualificato dall'assembly del tipo, che include il nome dell'assembly da cui è stato caricato l'oggetto 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

Valore della proprietà

Nome qualificato dall'assembly dell'oggetto Type, che include il nome dell'assembly da cui è stato caricato Type oppure null se l'istanza corrente rappresenta un parametro di tipo generico.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.

Implementazioni

Esempi

Nell'esempio seguente viene visualizzato il nome dell'assembly associato alla classe e il nome 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.

Nell'esempio seguente vengono ToString confrontate le stringhe restituite dal metodo e le Nameproprietà AssemblyQualifiedName , FullNamee.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

Commenti

Il nome qualificato dall'assembly di un tipo è costituito dal nome del tipo, incluso il relativo spazio dei nomi, seguito da una virgola, seguito dal nome visualizzato dell'assembly.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. Il nome visualizzato di un assembly viene ottenuto utilizzando la Assembly.FullName proprietà.The display name of an assembly is obtained using the Assembly.FullName property.

Nota

In .NET Framework versione 2,0, l'architettura del processore viene aggiunta all'identità dell'assembly e può essere specificata come parte delle stringhe dei nomi degli assembly.In the .NET Framework version 2.0, processor architecture is added to assembly identity, and can be specified as part of assembly name strings. Ad esempio, "ProcessorArchitecture = msil".For example, "ProcessorArchitecture=msil". Tuttavia, non è incluso nella stringa restituita dalla AssemblyQualifiedName proprietà, per motivi di compatibilità.However, it is not included in the string returned by the AssemblyQualifiedName property, for compatibility reasons. Vedere AssemblyName.ProcessorArchitecture.See AssemblyName.ProcessorArchitecture.

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

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.
Punto (.)Period (.) Indica gli identificatori degli spazi dei nomi.Denotes namespace identifiers.
Parentesi quadre ([])Brackets ([]) Dopo un nome di tipo, indica una matrice di quel tipo.After a type name, denotes an array of that type.

In alternativa-or-

Per un tipo generico, racchiude l'elenco di argomenti di tipo generico.For a generic type, encloses the generic type argument list.

-oppure--or-

All'interno di un elenco di argomenti di tipo, racchiude un tipo qualificato dall'assembly.Within a type argument list, encloses an assembly-qualified type.

Il nome qualificato dall'assembly di una classe, ad esempio, potrebbe essere simile al seguente: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  

Se lo spazio dei nomi contiene un segno più, ad esempio Namespace. Sub + Namespace, il segno più (+) sarà preceduto da un carattere di escape (\) per impedire che venga interpretato come separatore di annidamento.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 reflection genera questa stringa nel modo seguente:Reflection would emit this string as follows:

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

"+ +"\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.

I nomi dei tipi possono includere caratteri finali che indicano informazioni aggiuntive sul tipo, ad esempio se il tipo è un tipo di riferimento, un tipo di puntatore o un tipo di matrice.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. Per recuperare il nome del tipo senza questi caratteri finali, usare t.GetElementType().ToString(), dove t è il tipo.To retrieve the type name without these trailing characters, use t.GetElementType().ToString(), where t is the type.

Gli spazi sono rilevanti in tutti i componenti del nome del tipo, eccetto il nome dell'assembly.Spaces are relevant in all type name components except the assembly name. Nel nome dell'assembly, gli spazi prima del separatore ',' sono rilevanti, ma gli spazi dopo il separatore ',' vengono ignorati.In the assembly name, spaces before the ',' separator are relevant, but spaces after the ',' separator are ignored.

Gli argomenti generici dei tipi generici vengono qualificati in base al nome dell'assembly.Generic arguments of generic types are themselves qualified by assembly name. Ad esempio, nel nome del tipo qualificato dall'assembly per MyGenericClass<int> (MyGenericClass(Of Integer) in Visual Basic), int viene espanso al nome del tipo qualificato dall'assembly per Int32.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.

Se l'oggetto Type corrente rappresenta un parametro generico, la proprietà restituisce null.If the current Type object represents a generic parameter, this property returns null.

Si applica a

Vedi anche