Type.IsSubclassOf(Type) Método

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Source:

Type.Helpers.cs

Determina si el Type actual se deriva del Type especificado.

public:
 virtual bool IsSubclassOf(Type ^ c);

public virtual bool IsSubclassOf (Type c);

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.

Devoluciones

Boolean

Es true si el Type actual se quita de c; en caso contrario, es false. Este método también devuelve false si c y el Type actual son iguales.

Excepciones

ArgumentNullException

c es null.

Ejemplos

En el ejemplo siguiente se crea una clase denominada Class1 y una clase derivada denominada DerivedC1. Llama al IsSubclassOf método para mostrar que DerivedC1 es una subclase de 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

type Class1() = class end
type DerivedC1() = inherit Class1()

printfn $"DerivedC1 subclass of Class1: {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:

• Si una clase deriva de otra.

• Si un tipo deriva de ValueType. Sin embargo, es IsValueType una manera más eficaz de determinar si un tipo es un tipo de valor.

• Si un tipo deriva de Enum. Sin embargo, el IsEnum método es una manera más eficaz de determinar si un tipo es una enumeración.

• Si un tipo es un delegado, es decir, si se deriva de Delegate o MulticastDelegate.

No se puede usar el IsSubclassOf método para determinar si una interfaz deriva de otra interfaz o si una clase implementa una interfaz. Use el IsAssignableFrom método para ese propósito, como se muestra en el ejemplo siguiente.

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

type IInterface =
    abstract Display : unit -> unit

type Implementation() =
    interface IInterface with
        member _.Display() = printfn "The implementation..."

printfn $"Implementation is a subclass of IInterface:   {typeof<Implementation>.IsSubclassOf typeof<IInterface>}"
printfn $"IInterface is assignable from Implementation: {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 objeto actual Type representa un parámetro de tipo en la definición de un tipo genérico o 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.

Nota:

Excepto cuando se usa con interfaces, IsSubclassOf es el contrario de IsAssignableFrom. Es decir, si t1.IsSubclassOf(t2) es true, entonces t2.IsAssignableFrom(t1) también truees .

Este método se puede invalidar mediante una clase derivada.

Consulte también

• BaseType