Type.FullName Propriété

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Assembly:

netstandard.dll

Assembly:

mscorlib.dll

Obtient le nom qualifié complet du type, y compris son espace de noms, mais pas 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

Valeur de propriété

String

Nom qualifié complet du type, y compris son espace de noms, mais sans l'assembly ; ou null si l'instance actuelle représente un paramètre de type générique, un type de tableau, un type pointeur, un type byref reposant sur un paramètre de type ou un type générique qui n'est pas une définition de type générique mais contient des paramètres de type non résolus.

Implémente

FullName

Exemples

L’exemple suivant affiche le nom complet du type spécifié.

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.
'

L’exemple suivant compare les chaînes retournées par la ToString méthode et les Name FullName Propriétés, et 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

Remarques

Par exemple, le nom qualifié complet du String type est System.String . Comparez ceci avec le nom qualifié d’assembly retourné par la AssemblyQualifiedName propriété, qui se compose du nom complet et du nom complet de l’assembly.

Si le type actuel représente un type générique fermé, les arguments de type dans la chaîne retournée par la FullName propriété sont qualifiés par leur nom d’assembly complet, même si la représentation sous forme de chaîne du type générique lui-même n’est pas qualifiée par son nom d’assembly complet. L’exemple suivant illustre la différence dans la propriété FullName pour un type qui représente une définition de type générique et un qui représente un type générique fermé.

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]]

Cette propriété retourne null si :

• L' Type objet actuel représente un paramètre de type d’un type générique.

  L’exemple suivant récupère le paramètre de type du Nullable<T> type et tente d’afficher sa FullName propriété.

  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' Type objet actuel représente un type de tableau, un type pointeur ou un byref type basé sur un paramètre de type générique.

  L’exemple suivant définit un type générique, Generictype1<T> , avec trois méthodes : Display(T[]) , qui reçoit un tableau de type t ; HandleT(T) , qui reçoit un objet t et ChangeValue(ref T) , qui reçoit un objet t par référence. comme C# et Visual Basic ne permettent pas de définir T comme pointeur dans la HandleT méthode, nous devons appeler la MakePointerType méthode sur l' Type objet qui représente le type de paramètre de la méthode pour créer un pointeur vers un type générique. La sortie de l’exemple indique que dans les trois cas, la FullName propriété est 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)
  

• Le type actuel contient des paramètres de type générique qui n’ont pas été remplacés par des types spécifiques (autrement dit, la ContainsGenericParameters propriété retourne true ), mais le type n’est pas une définition de type générique (autrement dit, la IsGenericTypeDefinition propriété retourne false

  Dans l’exemple suivant, Derived<T> hérite de Base<T> . La BaseType propriété obtient l' Type objet qui représente le type de base de Derived<T> , et sa FullName propriété retourne 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
  

  Pour obtenir un FullName qui ne l’est pas null , vous pouvez utiliser la GetGenericTypeDefinition méthode pour obtenir la définition de type générique, comme l’illustre l’exemple.

Cette propriété est en lecture seule.

Voir aussi

• String
• Namespace
• AssemblyQualifiedName
• AssemblyName
• Spécification des noms de types qualifiés complets