Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Type.FullName propriété

 

Date de publication : novembre 2016

Obtient le nom qualifié complet du type, y compris son espace de noms, mais pas l'assembly.

Espace de noms:   System
Assembly:  mscorlib (dans mscorlib.dll)

public abstract string FullName { get; }

Valeur de propriété

Type: System.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

_Type.FullName

Par exemple, le nom qualifié complet de le String est de type System.String. Comparez cela avec le nom qualifié par un assembly retourné par la AssemblyQualifiedName propriété constitué du nom complet et le 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 FullNamepropriété sont qualifiés par leur nom complet de l’assembly, bien que la représentation sous forme de chaîne du type générique lui-même n’est pas qualifiée par son nom complet de l’assembly. L’exemple suivant illustre la différence dans la propriété FullName de type qui représente la définition de type générique 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]]

Cette propriété retourne null si :

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

    L’exemple suivant récupère le paramètre de type de la Nullable<T> type et tente d’afficher son 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
    
  • Actuel Type objet représente un type de tableau, un type pointeur, ou une 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 est transmis à un tableau du type T ; HandleT(T), qui est transmis un objet T ; et ChangeValue(ref T), un objet de T qui est passé par référence. C# et Visual Basic n’autorisent pas à définir T en tant que pointeur dans la HandleT (méthode), nous devons appeler la MakePointerType méthode sur le Type objet qui représente le type de paramètre pour créer un pointeur vers un type générique. La sortie de l’exemple montre que, dans les trois cas, le 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)
    
  • 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, le ContainsGenericParameters propriété renvoie true), mais le type n’est pas une définition de type générique (autrement dit, le IsGenericTypeDefinition propriété retourne false

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

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

Cette propriété est en lecture seule.

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

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.
 */

L’exemple suivant compare les chaînes retournées par la ToString (méthode) et le Name, FullName, et AssemblyQualifiedName Propriétés.

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

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

      t = typeof(System.Collections.Generic.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: {0}", t.Name);
      Console.WriteLine("Full Name: {0}", t.FullName);
      Console.WriteLine("ToString:  {0}", t.ToString());
      Console.WriteLine("Assembly Qualified Name: {0}",
                        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

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 1.1
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight
Disponible depuis 2.0
Silverlight pour Windows Phone
Disponible depuis 7.0
Windows Phone
Disponible depuis 8.1
Retour au début
Afficher: