Type.BaseType Propiedad

Definición

Obtiene el tipo del que hereda directamente el objeto Type actual.Gets the type from which the current Type directly inherits.

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 desde el cual el objeto Type actual hereda directamente, o null si el objeto Type actual representa la clase Object o una interfaz.The Type from which the current Type directly inherits, or null if the current Type represents the Object class or an interface.

Implementaciones

Ejemplos

En el siguiente ejemplo se muestra el uso de la propiedad BaseType.The following example demonstrates using the BaseType property.

using namespace System;
void main()
{
   Type^ t = int::typeid;
   Console::WriteLine( "{0} inherits from {1}.", t, t->BaseType );
}

using System;
class TestType 
{
    public static void Main() 
    {
        Type t = typeof(int);
        Console.WriteLine("{0} inherits from {1}.", t,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 mostrar la jerarquía de herencia completa de cada clase que se encuentra en un ensamblado.The following example uses recursion to list the complete inheritance hierarchy of each class found in an assembly. 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.The example defines a class named C that derives from a class named B, which, in turn, derives from a class named 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
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 el tipo actual hereda directamente.The base type is the type from which the current type directly inherits. Object es el único tipo que no tiene un tipo base, por lo que null se devuelve como el tipo base de Object.Object is the only type that does not have a base type, therefore null is returned as the base type of Object.

Las interfaces heredan de cero o más interfaces base; por lo tanto, esta propiedad devuelve null si el objeto Type representa una interfaz.Interfaces inherit from zero or more base interfaces; therefore, this property returns null if the Type object represents an interface. Las interfaces base se pueden determinar con GetInterfaces o FindInterfaces.The base interfaces can be determined with GetInterfaces or FindInterfaces.

Si el Type actual representa un tipo genérico construido, el tipo base refleja los argumentos genéricos.If the current Type represents a constructed generic type, the base type reflects the generic arguments. Por ejemplo, consideremos las siguientes declaraciones:For example, consider the following declarations:

generic<typename U> ref class B { };
generic<typename T> ref class C : B<T> { };
class B<U> { }
class C<T> : B<T> { }
Class B(Of U)
End Class
Class C(Of T)
    Inherits B(Of T)
End Class

Para el tipo construido C<int> (C(Of Integer) en Visual Basic), la propiedad BaseType devuelve B<int>.For the constructed type C<int> (C(Of Integer) in Visual Basic), the BaseType property returns B<int>.

Si el Type actual 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.If the current Type represents a type parameter of a generic type definition, BaseType returns the class constraint, that is, the class the type parameter must inherit. Si no hay ninguna restricción de clase, BaseType devuelve System.Object.If there is no class constraint, BaseType returns System.Object.

Esta propiedad es de sólo lectura.This property is read-only.

Se aplica a

Consulte también: