Type.FullName Proprietà

Definizione

Spazio dei nomi:

System

Assembly:

System.Runtime.dll

Assembly:

netstandard.dll

Assembly:

mscorlib.dll

Ottiene il nome completo del tipo, comprendente il relativo spazio dei nomi ma non l'assembly.

public:
 abstract property System::String ^ FullName { System::String ^ get(); };

public abstract string FullName { get; }

public abstract string? FullName { get; }

member this.FullName : string

Public MustOverride ReadOnly Property FullName As String

Valore della proprietà

String

Nome completo del tipo, incluso il relativo lo spazio dei nomi ma non l'assembly; oppure null se l'istanza corrente rappresenta un parametro di tipo generico, un tipo matrice, un tipo puntatore o un tipo byref basato su un parametro di tipo, o un tipo generico che non è una definizione di tipo generico ma contiene parametri di tipo non risolto.

Implementazioni

FullName

Esempio

Nell'esempio seguente viene visualizzato il nome completo del tipo specificato.

using namespace System;
int main()
{
   Type^ t = Array::typeid;
   Console::WriteLine( "The full name of the Array type is {0}.", t->FullName );
}

/* This example produces the following output:

The full name of the Array type is System.Array.
 */

using System;
class TestFullName
{
public static void Main()
    {
    Type t = typeof(Array);
    Console.WriteLine("The full name of the Array type is {0}.", t.FullName);
    }
}

/* This example produces the following output:

The full name of the Array type is System.Array.
 */

Class TestFullName
   
    Public Shared Sub Main()
        Dim t As Type = GetType(Array)
        Console.WriteLine("The full name of the Array type is {0}.", t.FullName)
    End Sub
End Class

' This example produces the following output:
'
'The full name of the Array type is System.Array.
'

Nell'esempio seguente vengono confrontate le stringhe restituite dal ToString metodo e le proprietà , e Name FullName AssemblyQualifiedName .

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

Ad esempio, il nome completo del String tipo è System.String . A differenza del nome completo dell'assembly restituito dalla proprietà , costituito dal AssemblyQualifiedName nome completo più il nome completo dell'assembly.

Se il tipo corrente rappresenta un tipo generico chiuso, gli argomenti di tipo nella stringa restituita dalla proprietà sono qualificati dal nome completo dell'assembly, anche se la rappresentazione di stringa del tipo generico stesso non è qualificata dal nome FullName completo dell'assembly. Nell'esempio seguente viene illustrata la differenza nella proprietà FullName per un tipo che rappresenta una definizione di tipo generico e una che rappresenta un tipo generico chiuso.

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      Type t = typeof(List<>);
      Console.WriteLine(t.FullName);
      Console.WriteLine();

      List<String> list = new List<String>();
      t = list.GetType();
      Console.WriteLine(t.FullName);
   }
}
// The example displays the following output:
// System.Collections.Generic.List`1
//
// System.Collections.Generic.List`1[[System.String, mscorlib,
//        Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]

Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim t As Type = GetType(List(Of))
      Console.WriteLine(t.FullName)
      Console.WriteLine()

      Dim list As New List(Of String)()
      t = list.GetType()
      Console.WriteLine(t.FullName)
   End Sub
End Module
' The example displays the following output:
'    System.Collections.Generic.List`1
'
'    System.Collections.Generic.List`1[[System.String, mscorlib,
'             Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]

Questa proprietà restituisce null se:

• TypeL'oggetto corrente rappresenta un parametro di tipo di un tipo generico.

  Nell'esempio seguente viene recuperato il parametro di tipo Nullable<T> del tipo e viene tentata la visualizzazione della relativa proprietà FullName .

  using System;
  using System.Reflection;
  
  public class Example
  {
     public static void Main()
     {
        Type t = typeof(Nullable<>); 
        Console.WriteLine(t.FullName);
        if (t.IsGenericType) {
           Console.Write("   Generic Type Parameters: ");
           Type[] gtArgs = t.GetGenericArguments();
           for (int ctr = 0; ctr < gtArgs.Length; ctr++) {
              Console.WriteLine(gtArgs[ctr].FullName ??
                                "(unassigned) " + gtArgs[ctr].ToString());
            }
           Console.WriteLine();
        }
     }
  }
  // The example displays the following output:
  //       System.Nullable`1
  //          Generic Type Parameters: (unassigned) T
  

  Imports System.Reflection
  
  Module Example
     Public Sub Main()
        Dim t As Type = GetType(Nullable(Of )) 
        Console.WriteLine(t.FullName)
        If t.IsGenericType Then
           Console.Write("   Generic Type Parameters: ")
           Dim gtArgs As Type() = t.GetGenericArguments
           For ctr As Integer = 0 To gtArgs.Length - 1
              Console.WriteLine(If(gtArgs(ctr).FullName, 
                                "(unassigned) " + gtArgs(ctr).ToString()))
              If ctr < gtArgs.Length - 1 Then Console.Write(", ")   
           Next
           Console.WriteLine()
        End If
     End Sub
  End Module
  ' The example displays the following output:
  '       System.Nullable`1
  '          Generic Type Parameters: (unassigned) T
  

• L'oggetto corrente rappresenta un tipo matrice, un tipo puntatore o un tipo Type basato su un parametro di tipo byref generico.

  Nell'esempio seguente viene definito un tipo generico, , con tre metodi: , a cui viene passata una matrice di tipo T; , a cui viene passato un oggetto T e , a cui viene passato un oggetto T per Generictype1<T> Display(T[]) HandleT(T) ChangeValue(ref T) riferimento. Poiché C# e Visual Basic non consentono di definire T come puntatore nel metodo , è necessario chiamare il metodo sull'oggetto che rappresenta il tipo di parametro del metodo per creare un puntatore a un tipo HandleT MakePointerType Type generico. L'output dell'esempio mostra che in tutti e tre i casi la FullName proprietà è null .

  using System;
  using System.Reflection;
  
  public class GenericType1<T> 
  {
     public void Display(T[] elements)  
     {}
     
     public void HandleT(T obj)
     {}
     
     public bool ChangeValue(ref T arg) 
     {
        return true;
     }
  }
  
  public class Example
  {
     public static void Main()
     {
        Type t = typeof(GenericType1<>);
        Console.WriteLine("Type Name: {0}", t.FullName);
        MethodInfo[] methods = t.GetMethods(BindingFlags.Instance |
                                            BindingFlags.DeclaredOnly |
                                            BindingFlags.Public);
        foreach (var method in methods) { 
           Console.WriteLine("   Method: {0}", method.Name);
           // Get method parameters.
           ParameterInfo param = method.GetParameters()[0];
           Type paramType = param.ParameterType;
           if (method.Name == "HandleT")
              paramType = paramType.MakePointerType();
           Console.WriteLine("      Parameter: {0}", 
                             paramType.FullName ?? 
                             paramType.ToString() + " (unassigned)");
        }
     }
  }
  // The example displays the following output:
  //       Type Name: GenericType1`1
  //          Method: Display
  //             Parameter: T[] (unassigned))
  //          Method: HandleT
  //             Parameter: T* (unassigned)
  //          Method: ChangeValue
  //             Parameter: T& (unassigned)
  

  Imports System.Reflection
  
  Public Class GenericType1(Of T)
     Public Sub Display(elements As T())
     End Sub
     
     ' Visual Basic does not support pointer types.
     Public Sub HandleT(obj As T)
     End Sub
     
     
     Public Function ChangeValue(ByRef arg As T) As Boolean
        Return True
     End Function
  End Class
  
  Module Example
     Public Sub Main()
        Dim t As Type = GetType(GenericType1(Of ))
        Console.WriteLine("Type Name: {0}", t.FullName)
        Dim methods() As MethodInfo = t.GetMethods(BindingFlags.Instance Or
                                                   BindingFlags.DeclaredOnly Or
                                                   BindingFlags.Public)
        For Each method In methods 
           Console.WriteLine("   Method: {0}", method.Name)
           ' Get method parameters.
           Dim param As ParameterInfo = method.GetParameters()(0)
           Dim paramType As Type = param.ParameterType
           If method.Name = "HandleT" Then
              paramType = paramType.MakePointerType()
           End If
           Console.WriteLine("      Parameter: {0}", 
                             If(paramType.FullName, 
                                paramType.ToString() + " (unassigned)"))
        Next
     End Sub
  End Module
  ' The example displays the following output:
  '       Type Name: GenericType1`1
  '          Method: Display
  '             Parameter: T[] (unassigned)
  '          Method: HandleT
  '             Parameter: T* (unassigned)
  '          Method: ChangeValue
  '             Parameter: T& (unassigned)
  

• Il tipo corrente contiene parametri di tipo generico che non sono stati sostituiti da tipi specifici , ovvero la proprietà restituisce , ma il tipo non è una definizione di tipo generico, ovvero la proprietà ContainsGenericParameters true IsGenericTypeDefinition restituisce false

  Nell'esempio seguente eredita Derived<T> da Base<T> . La BaseType proprietà ottiene Type l'oggetto che rappresenta il tipo di base di e la relativa proprietà restituisce Derived<T> FullName null .

  using System;
  using System.Reflection;
  
  public class Base<T> { }
  
  public class Derived<T> : Base<T> { }
  
  public class Example
  {
     public static void Main()
     {
        Type t = typeof(Derived<>);
        Console.WriteLine("Generic Class: {0}", t.FullName);
        Console.WriteLine("   Contains Generic Paramters: {0}",
                          t.ContainsGenericParameters);
        Console.WriteLine("   Generic Type Definition: {0}\n",
                          t.IsGenericTypeDefinition);                 
  
        Type baseType = t.BaseType;
        Console.WriteLine("Its Base Class: {0}", 
                          baseType.FullName ?? 
                          "(unassigned) " + baseType.ToString());
        Console.WriteLine("   Contains Generic Paramters: {0}",
                          baseType.ContainsGenericParameters);
        Console.WriteLine("   Generic Type Definition: {0}",
                          baseType.IsGenericTypeDefinition);                 
        Console.WriteLine("   Full Name: {0}\n", 
                          baseType.GetGenericTypeDefinition().FullName);
  
        t = typeof(Base<>);
        Console.WriteLine("Generic Class: {0}", t.FullName);
        Console.WriteLine("   Contains Generic Paramters: {0}",
                          t.ContainsGenericParameters);
        Console.WriteLine("   Generic Type Definition: {0}\n",
                          t.IsGenericTypeDefinition);                 
     }
  }
  // The example displays the following output:
  //       Generic Class: Derived`1
  //          Contains Generic Paramters: True
  //          Generic Type Definition: True
  //       
  //       Its Base Class: (unassigned) Base`1[T]
  //          Contains Generic Paramters: True
  //          Generic Type Definition: False
  //          Full Name: Base`1
  //       
  //       Generic Class: Base`1
  //          Contains Generic Paramters: True
  //          Generic Type Definition: True
  

  Imports System.Reflection
  
  Public Class Base(Of T)
  End Class
  
  Public Class Derived(Of T) : Inherits Base(Of T)
  End Class
  
  Module Example
     Public Sub Main()
        Dim t As Type = GetType(Derived(Of ))
        Console.WriteLine("Generic Class: {0}", t.FullName)
        Console.WriteLine("   Contains Generic Paramters: {0}",
                          t.ContainsGenericParameters)
        Console.WriteLine("   Generic Type Definition: {0}",
                          t.IsGenericTypeDefinition)                 
        Console.WriteLine()
        
        Dim baseType As Type = t.BaseType
        Console.WriteLine("Its Base Class: {0}", 
                          If(baseType.FullName,  
                          "(unassigned) " + baseType.ToString()))
        Console.WriteLine("   Contains Generic Paramters: {0}",
                          baseType.ContainsGenericParameters)
        Console.WriteLine("   Generic Type Definition: {0}",
                          baseType.IsGenericTypeDefinition)                 
        Console.WriteLine("   Full Name: {0}", 
                          baseType.GetGenericTypeDefinition().FullName)
        Console.WriteLine()
        
        t = GetType(Base(Of ))
        Console.WriteLine("Generic Class: {0}", t.FullName)
        Console.WriteLine("   Contains Generic Paramters: {0}",
                          t.ContainsGenericParameters)
        Console.WriteLine("   Generic Type Definition: {0}",
                          t.IsGenericTypeDefinition)                 
     End Sub
  End Module
  ' The example displays the following output:
  '       Generic Class: Derived`1
  '          Contains Generic Paramters: True
  '          Generic Type Definition: True
  '       
  '       Its Base Class: (unassigned) Base`1[T]
  '          Contains Generic Paramters: True
  '          Generic Type Definition: False
  '          Full Name: Base`1
  '       
  '       Generic Class: Base`1
  '          Contains Generic Paramters: True
  '          Generic Type Definition: True
  

  Per ottenere un oggetto che non è , è possibile usare il metodo per ottenere la definizione di tipo FullName null GetGenericTypeDefinition generico, come illustrato nell'esempio.

Questa proprietà è di sola lettura.

Vedi anche

• String
• Namespace
• AssemblyQualifiedName
• AssemblyName
• Specifica di nomi di tipo completi