Type.IsSubclassOf(Type) Método

Definición

Determina si el Type actual se deriva del Type especificado.Determines whether the current Type derives from the specified Type.

public:
 virtual bool IsSubclassOf(Type ^ c);
public virtual bool IsSubclassOf (Type c);
[System.Runtime.InteropServices.ComVisible(true)]
public virtual bool IsSubclassOf (Type c);
abstract member IsSubclassOf : Type -> bool
override this.IsSubclassOf : Type -> bool
[<System.Runtime.InteropServices.ComVisible(true)>]
abstract member IsSubclassOf : Type -> bool
override this.IsSubclassOf : Type -> bool
Public Overridable Function IsSubclassOf (c As Type) As Boolean

Parámetros

c
Type

Tipo que se va a comparar con el tipo actual.The type to compare with the current type.

Devoluciones

Boolean

Es true si el Type actual se quita de c; en caso contrario, es false.true if the current Type derives from c; otherwise, false. Este método también devuelve false si c y el Type actual son iguales.This method also returns false if c and the current Type are equal.

Implementaciones

Atributos

Excepciones

El valor de c es null.c is null.

Ejemplos

En el ejemplo siguiente se crea una clase denominada Class1 y una clase derivada denominada DerivedC1 .The following example creates a class named Class1 and a derived class named DerivedC1. Llama al IsSubclassOf método para mostrar que DerivedC1 es una subclase de Class1 .It calls the IsSubclassOf method to show that DerivedC1 is a subclass of Class1.

using System;

public class Class1 { }
public class DerivedC1 : Class1 { }

class IsSubclassTest
{
   public static void Main()
   {
      Console.WriteLine("DerivedC1 subclass of Class1: {0}",
                         typeof(DerivedC1).IsSubclassOf(typeof(Class1)));
   }
}
// The example displays the following output:
//        DerivedC1 subclass of Class1: True
Public Class Class1
End Class

Public Class DerivedC1 : Inherits Class1
End Class

Public Module Example
   Public Sub Main()
      Console.WriteLine("DerivedC1 subclass of Class1: {0}",
                         GetType(DerivedC1).IsSubClassOf(GetType(Class1)))
   End Sub
End Module
' The example displays the following output:
'       DerivedC1 subclass of Class1: True

Comentarios

Puede llamar al IsSubclassOf método para determinar cualquiera de las siguientes opciones:You can call the IsSubclassOf method to determine any of the following:

  • Si una clase se deriva de otra.Whether one class derives from another.

  • Si un tipo se deriva de ValueType .Whether a type derives from ValueType. Sin embargo, IsValueType es una manera más eficaz de determinar si un tipo es un tipo de valor.However, the IsValueType is a more efficient way to determine whether a type is a value type.

  • Si un tipo se deriva de Enum .Whether a type derives from Enum. Sin embargo, el IsEnum método es una manera más eficaz de determinar si un tipo es una enumeración.However, the IsEnum method is a more efficient way to determine whether a type is an enumeration.

  • Si un tipo es un delegado, es decir, si se deriva de Delegate o MulticastDelegate .Whether a type is a delegate, that is, whether it derives from either Delegate or MulticastDelegate.

El IsSubclassOf método no se puede usar para determinar si una interfaz se deriva de otra interfaz o si una clase implementa una interfaz.The IsSubclassOf method cannot be used to determine whether an interface derives from another interface, or whether a class implements an interface. Use el IsAssignableFrom método para ese propósito, como se muestra en el ejemplo siguiente.Use the IsAssignableFrom method for that purpose, as the following example shows.

using System;

public interface IInterface
{
   void Display();
}

public class Implementation : IInterface
{
   public void Display()
   {
      Console.WriteLine("The implementation...");
   }
}

public class Example
{
   public static void Main()
   {
      Console.WriteLine("Implementation is a subclass of IInterface:   {0}",
                        typeof(Implementation).IsSubclassOf(typeof(IInterface)));
      Console.WriteLine("IInterface is assignable from Implementation: {0}",
                        typeof(IInterface).IsAssignableFrom(typeof(Implementation)));
   }
}
// The example displays the following output:
//       Implementation is a subclass of IInterface:   False
//       IInterface is assignable from Implementation: True
Public Interface IInterface
   Sub Display()
End Interface

Public Class Implementation : Implements IInterface
   Public Sub Display() _
      Implements IInterface.Display

      Console.WriteLine("The implementation...")
   End Sub
End Class

Module Example
   Public Sub Main()
      Console.WriteLine("Implementation is a subclass of IInterface:   {0}",
                        GetType(Implementation).IsSubclassOf(GetType(IInterface)))
      Console.WriteLine("IInterface is assignable from Implementation: {0}",
                        GetType(IInterface).IsAssignableFrom(GetType(Implementation)))
   End Sub
End Module
' The example displays the following output:
'       Implementation is a subclass of IInterface:   False
'       IInterface is assignable from Implementation: True

Si el actual Type representa un parámetro de tipo en la definición de un tipo genérico o de un método genérico, se deriva de su restricción de clase o de System.Object si no tiene ninguna restricción de clase.If the current Type represents a type parameter in the definition of a generic type or generic method, it derives from its class constraint or from System.Object if it has no class constraint.

Nota

Excepto cuando se usa con interfaces, IsSubclassOf es el opuesto de IsAssignableFrom .Except when used with interfaces, IsSubclassOf is the converse of IsAssignableFrom. Es decir, si t1.IsSubclassOf(t2) es true , t2.IsAssignableFrom(t1) también es true .That is, if t1.IsSubclassOf(t2) is true, then t2.IsAssignableFrom(t1) is also true.

Este método se puede invalidar mediante una clase derivada.This method can be overridden by a derived class.

Se aplica a

Consulte también