Type.IsSubclassOf(Type) Méthode

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

Paramètres

Retours

true si le Type actuel dérive de c ; sinon false. Cette méthode retourne également false si c et le Type actuel sont égaux.

Implémente

Attributs

ComVisibleAttribute

Exceptions

Exemples

L’exemple suivant crée une classe nommée Class1 et une classe dérivée nommée DerivedC1. Il appelle la IsSubclassOf méthode pour montrer qu’il DerivedC1 s’agit d’une sous-classe 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

Remarques

Vous pouvez appeler la IsSubclassOf méthode pour déterminer l’un des éléments suivants :

• Indique si une classe dérive d’une autre.

• Indique si un type dérive de ValueType. Toutefois, le IsValueType est un moyen plus efficace de déterminer si un type est un type valeur.

• Indique si un type dérive de Enum. Toutefois, la IsEnum méthode est un moyen plus efficace de déterminer si un type est une énumération.

• Si un type est un délégué, c’est-à-dire s’il dérive de Delegate ou MulticastDelegate.

La IsSubclassOf méthode ne peut pas être utilisée pour déterminer si une interface dérive d’une autre interface ou si une classe implémente une interface. Utilisez la IsAssignableFrom méthode à cet effet, comme le montre l’exemple suivant.

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 le current Type représente un paramètre de type dans la définition d’un type générique ou d’une méthode générique, il dérive de sa contrainte de classe ou de s’il n’a aucune contrainte de System.Object classe.

Cette méthode peut être remplacée par une classe dérivée.

S’applique à

Voir aussi

• BaseType