Type.FullName Propiedad

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Ensamblado:

netstandard.dll

Ensamblado:

mscorlib.dll

Obtiene el nombre completo del tipo, incluido su espacio de nombres, pero no su ensamblado.

C#

public abstract string FullName { get; }

C#

public abstract string? FullName { get; }

Valor de propiedad

String

Nombre completo del tipo, con espacio de nombres y sin ensamblado; o bien, null si la instancia actual representa un parámetro de tipo genérico, un tipo de matriz, un tipo de puntero o un tipo byref basado en un parámetro de tipo, o un tipo genérico que no sea una definición de tipo genérico, pero que contenga parámetros de tipo sin resolver.

Implementaciones

FullName

Ejemplos

En el ejemplo siguiente se muestra el nombre completo del tipo especificado.

C#

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

En el ejemplo siguiente se comparan las cadenas devueltas por el ToString método y las propiedades , y Name FullName AssemblyQualifiedName .

C#

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

Comentarios

Por ejemplo, el nombre completo del String tipo es System.String . Compare esto con el nombre completo del ensamblado devuelto por la propiedad , que consta del nombre AssemblyQualifiedName completo más el nombre completo del ensamblado.

Si el tipo actual representa un tipo genérico cerrado, los argumentos de tipo de la cadena devuelta por la propiedad se califican por su nombre de ensamblado completo, aunque la representación de cadena del propio tipo genérico no está calificada por su nombre de ensamblado FullName completo. En el ejemplo siguiente se muestra la diferencia en la propiedad FullName para un tipo que representa la definición de tipo genérico y otro que representa un tipo genérico cerrado.

C#

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

Esta propiedad devuelve null si:

• El objeto Type actual representa un parámetro de tipo de un tipo genérico.

  En el ejemplo siguiente se recupera el parámetro de tipo del Nullable<T> tipo e intenta mostrar su propiedad FullName .

  C#

  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
  

• El objeto Type actual representa un tipo de matriz, un tipo de puntero o un tipo basado en un parámetro de tipo byref genérico.

  En el ejemplo siguiente se define un tipo genérico, , con tres métodos: , al que se pasa una matriz de tipo T; , al que se pasa un objeto T; y , al que se pasa un objeto T por Generictype1<T> Display(T[]) HandleT(T) ChangeValue(ref T) referencia. Dado que C# y Visual Basic no nos permiten definir T como puntero en el método , tenemos que llamar al método en el objeto que representa el tipo de parámetro del método para crear un puntero a un tipo HandleT MakePointerType Type genérico. La salida del ejemplo muestra que, en los tres casos, la FullName propiedad es null .

  C#

  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)
  

• El tipo actual contiene parámetros de tipo genérico que no se han reemplazado por tipos específicos (es decir, la propiedad devuelve ), pero el tipo no es una definición de tipo genérico ContainsGenericParameters true (es decir, la IsGenericTypeDefinition propiedad devuelve false

  En el ejemplo siguiente, Derived<T> hereda de Base<T> . La BaseType propiedad obtiene el objeto que representa el tipo base de y su propiedad devuelve Type Derived<T> FullName null .

  C#

  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
  

  Para obtener un que no es , puede usar el método para obtener la definición de tipo genérico, como se muestra FullName en el null GetGenericTypeDefinition ejemplo.

Esta propiedad es de sólo lectura.

Se aplica a

Consulte también

• String
• Namespace
• AssemblyQualifiedName
• AssemblyName
• Especificar nombres de tipo completos