Type.BaseType Propriété

Définition

Espace de noms:

System

Assemblys:

netstandard.dll, System.Runtime.dll

Source:

Type.cs

Obtient le type à partir duquel le Type actuel hérite directement.

public:
 abstract property Type ^ BaseType { Type ^ get(); };

public abstract Type? BaseType { get; }

member this.BaseType : Type

Public MustOverride ReadOnly Property BaseType As Type

Valeur de propriété

Type

Type À partir duquel le courant Type hérite directement, ou null si le courant Type représente la Object classe ou une interface.

Exemples

L’exemple suivant illustre l’utilisation de la BaseType propriété.

using System;
class TestType
{
    public static void Main()
    {
        Type t = typeof(int);
        Console.WriteLine("{0} inherits from {1}.", t,t.BaseType);
    }
}

let t = typeof<int>
printfn $"{t} inherits from {t.BaseType}."

Class TestType
   
    Public Shared Sub Main()
        Dim t As Type = GetType(Integer)
        Console.WriteLine("{0} inherits from {1}.", t, t.BaseType)
    End Sub
End Class

L’exemple suivant utilise la récursivité pour répertorier la hiérarchie d’héritage complète de chaque classe trouvée dans un assembly. L’exemple définit une classe nommée C qui dérive d’une classe nommée B, qui, à son tour, dérive d’une classe nommée A.

using System;

public class Example
{
   public static void Main()
   {
      foreach (var t in typeof(Example).Assembly.GetTypes()) {
         Console.WriteLine("{0} derived from: ", t.FullName);
         var derived = t;
         do { 
            derived = derived.BaseType;
            if (derived != null) 
               Console.WriteLine("   {0}", derived.FullName);
         } while (derived != null);
         Console.WriteLine(); 
      } 
   }
}

public class A {} 

public class B : A
{}

public class C : B   
{}
// The example displays the following output:
//       Example derived from:
//          System.Object
//       
//       A derived from:
//          System.Object
//       
//       B derived from:
//          A
//          System.Object
//       
//       C derived from:
//          B
//          A
//          System.Object

type A() = class end 

type B() = inherit A()

type C() = inherit B()   

module Example =
    [<EntryPoint>]
    let main _ =
        for t in typeof<A>.Assembly.GetTypes() do
            printfn $"{t.FullName} derived from: "
            let mutable derived = t
            while derived <> null do
                derived <- derived.BaseType
                if derived <> null then 
                    printfn $"   {derived.FullName}"
            printfn ""
        0
// The example displays the following output:
//       Example derived from:
//          System.Object
//       
//       A derived from:
//          System.Object
//       
//       B derived from:
//          A
//          System.Object
//       
//       C derived from:
//          B
//          A
//          System.Object

Public Class Example
   Public Shared Sub Main()
      For Each t In GetType(Example).Assembly.GetTypes()
         Console.WriteLine("{0} derived from: ", t.FullName)
         Dim derived As Type = t
         Do 
            derived = derived.BaseType
            If derived IsNot Nothing Then 
               Console.WriteLine("   {0}", derived.FullName)
            End If   
         Loop While derived IsNot Nothing
         Console.WriteLine() 
      Next 
   End Sub
End Class

Public Class A 
End Class

Public Class B : Inherits A
End Class

Public Class C : Inherits B
End Class
' The example displays the following output:
'       Example derived from:
'          System.Object
'       
'       A derived from:
'          System.Object
'       
'       B derived from:
'          A
'          System.Object
'       
'       C derived from:
'          B
'          A
'          System.Object

Remarques

Le type de base est le type à partir duquel le type actuel hérite directement. Object est le seul type qui n’a pas de type de base, par conséquent null est retourné comme type de base de Object.

Les interfaces héritent de zéro ou plusieurs interfaces de base ; par conséquent, cette propriété retourne null si l’objet Type représente une interface. Les interfaces de base peuvent être déterminées avec GetInterfaces ou FindInterfaces.

Si le courant Type représente un type générique construit, le type de base reflète les arguments génériques. Observez, par exemple, les déclarations suivantes :

class B<U> { }
class C<T> : B<T> { }

type B<'U>() = class end
type C<'T>() = inherit B<'T>()

Class B(Of U)
End Class
Class C(Of T)
    Inherits B(Of T)
End Class

Pour le type C<int> construit (C(Of Integer) en Visual Basic), la BaseType propriété retourne B<int>.

Si le paramètre actuel Type représente un paramètre de type d’une définition de type générique, BaseType retourne la contrainte de classe, autrement dit, la classe que le paramètre de type doit hériter. S’il n’existe aucune contrainte de classe, BaseType retourne System.Object.

Cette propriété est en lecture seule.

Voir aussi

• Object
• GetInterfaces()
• FindInterfaces(TypeFilter, Object)
• UnderlyingSystemType
• IsSubclassOf(Type)
• Réflexion et types génériques