Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

Type.FullName-Eigenschaft

 

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

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)

public abstract string FullName { get; }

Eigenschaftswert

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

_Type.FullName

Z. B. den vollqualifizierten Namen von der String ist System.String. Vergleichen Sie dies mit dem assemblyqualifizierten Namen zurückgegeben werden, indem die AssemblyQualifiedName -Eigenschaft, die den vollständigen Namen sowie den vollständigen Assemblynamen besteht.

Wenn der aktuelle Typ einen geschlossenen generischen Typ darstellt, die Typargumente in der Zeichenfolge zurückgegeben, durch die FullNameEigenschaft sind durch ihren vollständigen Assemblynamen, gekennzeichnet, obwohl die Darstellung des generischen Typs selbst nicht durch den vollständigen Assemblynamen qualifiziert wird. Das folgende Beispiel veranschaulicht den Unterschied in der FullName-Eigenschaft für einen Typ, der generische Typdefinition darstellt, und eine, die einen geschlossenen generischen Typ darstellt.

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 Wenn:

  • Die aktuelle Type -Objekt einen Typparameter eines generischen Typs darstellt.

    Das folgende Beispiel ruft die Typparameter der Nullable<T> Typ und versucht, Anzeigen der FullName Eigenschaft.

    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
    
  • Die aktuelle Type Objekt repräsentiert einen Arraytyp, Zeigertyp oder ein byref Typ, der einen generischen Typparameter basiert.

    Das folgende Beispiel definiert einen generischen Typ Generictype1<T>, mit drei Methoden: Display(T[]), ein Array vom Typ T; übergeben wird HandleT(T), ein T-Objekt übergeben wird und ChangeValue(ref T), die ein T-Objekt als Verweis übergeben wird. Da C#- und Visual Basic nicht wir T als Zeiger in definieren können die HandleT -Methode aufrufen, müssen die MakePointerType Methode für die Type -Objekt, das die Methode Parametertyp erstellen Sie einen Zeiger auf einen generischen Typ darstellt. Die Ausgabe des Beispiels zeigt, dass in allen drei Fällen die FullName Eigenschaft ist 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)
    
  • Der aktuelle Typ enthält generische Parameter, die nicht durch bestimmte Typen ersetzt wurden (d. h. die ContainsGenericParameters -Eigenschaft gibt true), ist jedoch keine Definition eines generischen Typs (, also die IsGenericTypeDefinition -Eigenschaft gibt false

    Im folgenden Beispiel Derived<T> erbt von Base<T>. Die BaseType Eigenschaft ruft die Type -Objekt, das den Basistyp darstellt Derived<T>, und seine FullName -Eigenschaft gibt 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
    

    Zum Abrufen einer FullName nicht null, können Sie die GetGenericTypeDefinition Methode, um die Definition eines generischen Typs abrufen, wie im Beispiel veranschaulicht.

Diese Eigenschaft ist schreibgeschützt.

Das folgende Beispiel zeigt den vollständigen Namen des angegebenen Typs.

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 Zeichenfolgen zurückgegeben werden, indem die ToString Methode und die Name, FullName, und AssemblyQualifiedName Eigenschaften.

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

Universal Windows Platform
Verfügbar seit 4.5
.NET Framework
Verfügbar seit 1.1
Portable Class Library
Unterstützt in: portable .NET platforms
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1
Zurück zum Anfang
Anzeigen: