Type.FullName Właściwość

Definicja

Przestrzeń nazw:

System

Zestaw:

System.Runtime.dll

Zestaw:

netstandard.dll

Zestaw:

mscorlib.dll

Pobiera w pełni kwalifikowaną nazwę typu, w tym jej przestrzeń nazw, ale nie zestaw.

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

Wartość właściwości

String

W pełni kwalifikowana nazwa typu, łącznie z przestrzenią nazw, ale nie jej zestawem; lub jeśli bieżące wystąpienie reprezentuje parametr typu ogólnego, typ tablicy, typ wskaźnika lub typ na podstawie parametru typu lub typ ogólny, który nie jest definicją typu ogólnego, ale zawiera nierozwiązane parametry null byref typu.

Implementuje

FullName

Przykłady

W poniższym przykładzie jest wyświetlana pełna nazwa określonego 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.
'

Poniższy przykład porównuje ciągi zwracane przez ToString metodę i właściwości , i 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

Uwagi

Na przykład w pełni kwalifikowana nazwa String typu to System.String . Porównaj to z nazwą kwalifikowaną zestawu zwróconą przez właściwość , która składa się z pełnej AssemblyQualifiedName nazwy i pełnej nazwy zestawu.

Jeśli bieżący typ reprezentuje zamknięty typ ogólny, argumenty typu w ciągu zwracanym przez właściwość są kwalifikowane przez pełną nazwę zestawu, mimo że reprezentacja ciągu samego typu ogólnego nie jest kwalifikowana przez pełną nazwę FullName zestawu. W poniższym przykładzie pokazano różnicę we właściwości FullName dla typu, który reprezentuje definicję typu ogólnego, i definicję, która reprezentuje zamknięty typ ogólny.

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

Ta właściwość zwraca null wartość, jeśli:

• Bieżący Type obiekt reprezentuje parametr typu typu ogólnego.

  Poniższy przykład pobiera parametr typu typu i próbuje Nullable<T> wyświetlić jego FullName właściwość.

  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
  

• Bieżący obiekt reprezentuje typ tablicy, typ wskaźnika lub typ, który jest Type byref oparty na parametrze typu ogólnego.

  W poniższym przykładzie zdefiniowano typ ogólny , z trzema metodami: , która jest przekazywana tablica typu T; , która jest przekazywana do obiektu T; i , która jest przekazywana do obiektu T przez Generictype1<T> Display(T[]) HandleT(T) ChangeValue(ref T) odwołanie. Ponieważ C# i Visual Basic nie umożliwiają definiowania T jako wskaźnika w metodzie, musimy wywołać metodę na obiekcie, który reprezentuje typ parametru metody, aby utworzyć wskaźnik do HandleT MakePointerType typu Type ogólnego. Dane wyjściowe z przykładu pokazują, że we wszystkich trzech przypadkach właściwość FullName to 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)
  

• Bieżący typ zawiera parametry typu ogólnego, które nie zostały zastąpione przez określone typy (czyli właściwość zwraca wartość ), ale typ nie jest definicją typu ogólnego ContainsGenericParameters true (to oznacza, że właściwość IsGenericTypeDefinition zwraca false

  W poniższym przykładzie Derived<T> dziedziczy z Base<T> . Właściwość BaseType uzyskuje obiekt Type reprezentujący typ podstawowy typu , a jej Derived<T> właściwość zwraca wartość 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
  

  Aby uzyskać typ , który nie jest , możesz użyć metody , aby uzyskać definicję typu FullName null GetGenericTypeDefinition ogólnego, jak pokazano w przykładzie.

Ta właściwość jest tylko do odczytu.

Zobacz też

• String
• Namespace
• AssemblyQualifiedName
• AssemblyName
• Określanie w pełni kwalifikowanych nazw typów