Type.FullName Eigenschaft

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Assembly:

netstandard.dll

Assembly:

mscorlib.dll

Ruft den voll vollqualifizierten Namen des Typs ab. Dies beinhaltet den Namespace, nicht jedoch die Assembly.

C#

public abstract string FullName { get; }

C#

public abstract string? FullName { get; }

Eigenschaftswert

String

Der vollqualifizierte Name des Typs, einschließlich des Namespace, jedoch ausschließlich der Assembly, oder null, wenn die aktuelle Instanz einen auf einem Typparameter basierenden generischen Typparameter, Arraytyp, Zeigertyp oder byref-Typ oder einen generischen Typ darstellt, der keine generische Typdefinition ist, jedoch nicht aufgelöste Typparameter enthält.

Implementiert

FullName

Beispiele

Im folgenden Beispiel wird der vollständige Name des angegebenen Typs angezeigt.

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

Im folgenden Beispiel werden die von der -Methode zurückgegebenen ToString Zeichenfolgen mit den Eigenschaften , und Name FullName AssemblyQualifiedName verglichen.

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

Hinweise

Der vollqualifizierte Name des Typs ist String beispielsweise System.String . Vergleichen Sie dies mit dem durch die Assembly qualifizierten Namen, der von der -Eigenschaft zurückgegeben wird, die aus dem vollständigen AssemblyQualifiedName Namen und dem vollständigen Assemblynamen besteht.

Wenn der aktuelle Typ einen geschlossenen generischen Typ darstellt, werden die Typargumente in der von der -Eigenschaft zurückgegebenen Zeichenfolge durch ihren vollständigen Assemblynamen qualifiziert, obwohl die Zeichenfolgendarstellung des generischen Typs selbst nicht durch den vollständigen Assemblynamen qualifiziert FullName ist. Das folgende Beispiel veranschaulicht den Unterschied in der FullName-Eigenschaft für einen Typ, der die generische Typdefinition darstellt, und eine, die einen geschlossenen generischen Typ darstellt.

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

Diese Eigenschaft gibt null zurück, wenn:

• Das aktuelle Type -Objekt stellt einen Typparameter eines generischen Typs dar.

  Im folgenden Beispiel wird der Typparameter des Typs abgerufen und Nullable<T> versucht, seine -Eigenschaft FullName anzuzeigen.

  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
  

• Das aktuelle -Objekt stellt einen Arraytyp, einen Zeigertyp oder einen Typ Type dar, byref der auf einem generischen Typparameter basiert.

  Im folgenden Beispiel wird ein generischer Typ mit drei Methoden definiert: , dem ein Array vom Typ T übergeben wird, , dem ein T-Objekt übergeben wird, und , dem ein T-Objekt als Verweis Generictype1<T> Display(T[]) übergeben HandleT(T) ChangeValue(ref T) wird. Da C# und Visual Basic nicht zulassen, T als Zeiger in der -Methode zu definieren, müssen wir die -Methode für das Objekt aufrufen, das den Parametertyp der Methode darstellt, um einen Zeiger auf einen generischen Typ zu HandleT MakePointerType Type erstellen. Die Ausgabe des Beispiels zeigt, dass in allen drei Fällen die FullName -Eigenschaft null ist.

  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)
  

• Der aktuelle Typ enthält generische Typparameter, die nicht durch bestimmte Typen ersetzt wurden (d. h. die Eigenschaft gibt zurück), aber der Typ ist keine generische Typdefinition (d. h. die Eigenschaft gibt ContainsGenericParameters true IsGenericTypeDefinition zurück). false

  Im folgenden Beispiel Derived<T> erbt von Base<T> . Die BaseType -Eigenschaft erhält das Type -Objekt, das den Basistyp von Derived<T> darstellt, und die FullName -Eigenschaft gibt null zurück.

  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
  

  Um einen zu erhalten, der nicht ist, können Sie die -Methode verwenden, um die generische Typdefinition zu FullName null GetGenericTypeDefinition erhalten, wie im Beispiel veranschaulicht.

Diese Eigenschaft ist schreibgeschützt.

Gilt für

Siehe auch

• String
• Namespace
• AssemblyQualifiedName
• AssemblyName
• Angeben vollständig gekennzeichneter Typnamen