Type.IsSubclassOf(Type) Método

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

Retornos

true se a atual Type deriva de c; caso contrário, false. Esse método também retorna false se c e a atual Type são iguais.

Implementações

Atributos

ComVisibleAttribute

Exceções

Exemplos

O exemplo a seguir cria uma classe nomeada Class1 e uma classe derivada chamada DerivedC1. Ele chama o IsSubclassOf método para mostrar que DerivedC1 é uma subclasse 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

Comentários

Você pode chamar o IsSubclassOf método para determinar qualquer um dos seguintes:

• Se uma classe deriva de outra.

• Se um tipo deriva de ValueType. No entanto, é IsValueType uma maneira mais eficiente de determinar se um tipo é um tipo de valor.

• Se um tipo deriva de Enum. No entanto, o IsEnum método é uma maneira mais eficiente de determinar se um tipo é uma enumeração.

• Se um tipo é um delegado, ou seja, se ele deriva de um Delegate ou MulticastDelegate.

O IsSubclassOf método não pode ser usado para determinar se uma interface deriva de outra interface ou se uma classe implementa uma interface. Use o IsAssignableFrom método para essa finalidade, como mostra o exemplo a seguir.

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

Se a corrente Type representar um parâmetro de tipo na definição de um tipo genérico ou método genérico, ela deriva de sua restrição de classe ou de se não tiver nenhuma restrição de System.Object classe.

Esse método pode ser substituído por uma classe derivada.

Confira também

• BaseType