Type.BaseType Propiedad

Definición

Espacio de nombres:

System

Ensamblados:

netstandard.dll, System.Runtime.dll

Source:

Type.cs

Obtiene el tipo del que hereda directamente el objeto actual Type .

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

public abstract Type? BaseType { get; }

member this.BaseType : Type

Public MustOverride ReadOnly Property BaseType As Type

Valor de propiedad

Type

del Type que hereda directamente el objeto actual Type o null si el objeto actual Type representa la Object clase o una interfaz.

Ejemplos

En el ejemplo siguiente se muestra el uso de la BaseType propiedad .

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

En el ejemplo siguiente se usa la recursividad para enumerar la jerarquía de herencia completa de cada clase que se encuentra en un ensamblado. En el ejemplo se define una clase denominada C que deriva de una clase denominada B, que, a su vez, deriva de una clase denominada 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

Comentarios

El tipo base es el tipo del que hereda directamente el tipo actual. Object es el único tipo que no tiene un tipo base, por lo que null se devuelve como el tipo base de Object.

Las interfaces heredan de cero o más interfaces base; por lo tanto, esta propiedad devuelve null si el Type objeto representa una interfaz. Las interfaces base se pueden determinar con GetInterfaces o FindInterfaces.

Si el objeto actual Type representa un tipo genérico construido, el tipo base refleja los argumentos genéricos. Por ejemplo, consideremos las siguientes declaraciones:

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

Para el tipo C<int> construido (C(Of Integer) en Visual Basic), la BaseType propiedad devuelve B<int>.

Si el objeto actual Type representa un parámetro de tipo de una definición de tipo genérico, BaseType devuelve la restricción de clase, es decir, la clase que el parámetro de tipo debe heredar. Si no hay ninguna restricción de clase, BaseType devuelve System.Object.

Esta propiedad es de solo lectura.

Consulte también

• Object
• GetInterfaces()
• FindInterfaces(TypeFilter, Object)
• UnderlyingSystemType
• IsSubclassOf(Type)
• Reflexión y tipos genéricos