Sdílet prostřednictvím


Type.FullName Vlastnost

Definice

Získá plně kvalifikovaný název typu, včetně jeho oboru názvů, ale ne jeho sestavení.

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

Hodnota vlastnosti

String

Plně kvalifikovaný název typu, včetně jeho oboru názvů, ale ne jeho sestavení; nebo pokud aktuální instance představuje parametr obecného typu, typ pole, typ ukazatele nebo typ na základě parametru typu nebo obecný typ, který není definicí obecného typu, ale obsahuje nevyřešené null byref parametry typu.

Implementuje

Příklady

Následující příklad zobrazí úplný název zadaného typu.

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

Následující příklad porovnává řetězce vrácené metodou ToString a vlastnosti , a Name FullName 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

Poznámky

Například plně kvalifikovaný název typu String je System.String . Porovnejte tento název s kvalifikovaným názvem sestavení vráceným vlastností , která se skládá z úplného názvu AssemblyQualifiedName a úplného názvu sestavení.

Pokud aktuální typ představuje uzavřený obecný typ, jsou argumenty typu v řetězci vráceném vlastností kvalifikovány úplným názvem sestavení, i když řetězcová reprezentace samotného obecného typu není kvalifikována celým názvem FullName sestavení. Následující příklad ukazuje rozdíl ve vlastnosti FullName pro typ, který představuje definici obecného typu, a ten, který představuje uzavřený obecný typ.

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

Tato vlastnost vrátí null , pokud:

  • Aktuální Type objekt představuje parametr typu obecného typu.

    Následující příklad načte parametr typu typu a pokusí Nullable<T> se zobrazit jeho FullName vlastnost.

    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
    
  • Aktuální objekt představuje typ pole, typ ukazatele nebo typ, který je založen Type byref na parametru obecného typu.

    Následující příklad definuje obecný typ se třemi metodami: , které je předáno pole typu T; , které je předáno objektu T; a , které je předáno objektu Generictype1<T> Display(T[]) T HandleT(T) ChangeValue(ref T) odkazem. Protože jazyk C# a Visual Basic neumožňují definovat T jako ukazatel v metodě , musíme volat metodu objektu, který představuje typ parametru metody, abychom vytvořili ukazatel na HandleT MakePointerType obecný Type typ. Výstup z příkladu ukazuje, že ve všech třech případech je FullName vlastnost 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)
    
  • Aktuální typ obsahuje parametry obecného typu, které nebyly nahrazeny konkrétními typy (to znamená, že vlastnost vrací ), ale typ není definicí obecného typu ContainsGenericParameters true (to znamená, že vlastnost vrací ). IsGenericTypeDefinitionfalse

    V následujícím příkladu Derived<T> dědí z Base<T> . Vlastnost BaseType získá Type objekt, který představuje základní typ , a Derived<T> jeho vlastnost vrátí FullName 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
    

    Pokud chcete získat , který není , můžete použít metodu k získání definice obecného typu, jak FullName null je GetGenericTypeDefinition znázorněno v příkladu.

Tato vlastnost je jen ke čtení.

Platí pro

Viz také