Type.IsSubclassOf(Type) Type.IsSubclassOf(Type) Type.IsSubclassOf(Type) Type.IsSubclassOf(Type) Method

Definition

Bestimmt, ob der aktuelle Type vom angegebenen Type abgeleitet ist.Determines whether the current Type derives from the specified Type.

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
Public Overridable Function IsSubclassOf (c As Type) As Boolean

Parameter

c
Type Type Type Type

Der Typ, der mit dem aktuellen Typ verglichen werden soll.The type to compare with the current type.

Gibt zurück

true, wenn der aktuelle Type von c abgeleitet ist, andernfalls false.true if the current Type derives from c; otherwise, false. Diese Methode gibt auch dann false zurück, wenn c und der aktuelle Type gleich sind.This method also returns false if c and the current Type are equal.

Implementiert

Ausnahmen

Beispiele

Im folgenden Beispiel wird eine Klasse Class1 mit dem Namen und eine abgeleitete Klasse mit dem Namen DerivedC1erstellt.The following example creates a class named Class1 and a derived class named DerivedC1. Die IsSubclassOf -Methode wird aufgerufen, um DerivedC1 anzuzeigen, dass eine unter Class1Klasse von ist.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

Hinweise

Die IsSubclassOf -Methode kann aufgerufen werden, um Folgendes zu bestimmen:You can call the IsSubclassOf method to determine any of the following:

  • Gibt an, ob eine Klasse von einer anderen abgeleitet ist.Whether one class derives from another.

  • Gibt an, ob ein ValueTypeTyp von abgeleitet ist.Whether a type derives from ValueType. Das IsValueType ist jedoch eine effizientere Methode, um zu bestimmen, ob ein Typ ein Werttyp ist.However, the IsValueType is a more efficient way to determine whether a type is a value type.

  • Gibt an, ob ein EnumTyp von abgeleitet ist.Whether a type derives from Enum. Die IsEnum -Methode ist jedoch eine effizientere Methode, um zu bestimmen, ob ein Typ eine Enumeration ist.However, the IsEnum method is a more efficient way to determine whether a type is an enumeration.

  • Gibt an, ob ein Typ ein Delegat ist, d. h. Delegate ob MulticastDelegateer entweder von oder abgeleitet ist.Whether a type is a delegate, that is, whether it derives from either Delegate or MulticastDelegate.

Die IsSubclassOf -Methode kann nicht verwendet werden, um zu bestimmen, ob eine Schnittstelle von einer anderen Schnittstelle abgeleitet wird oder ob eine Klasse eine Schnittstelle implementiert.The IsSubclassOf method cannot be used to determine whether an interface derives from another interface, or whether a class implements an interface. Verwenden Sie IsAssignableFrom für diesen Zweck die-Methode, wie im folgenden Beispiel gezeigt.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

Wenn der aktuelle Type einen Typparameter in der Definition eines generischen Typs oder einer generischen Methode darstellt, wird er von seiner Klassen Einschränkung System.Object oder von abgeleitet, wenn er keine Klassen Einschränkung aufweist.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.

Hinweis

Außer bei Verwendung mit-Schnitt IsSubclassOf stellen ist das Gegenteil IsAssignableFromvon.Except when used with interfaces, IsSubclassOf is the converse of IsAssignableFrom. Das heißt, wenn t1.IsSubclassOf(t2) ist true, dann t2.IsAssignableFrom(t1) ist ebenfalls true.That is, if t1.IsSubclassOf(t2) is true, then t2.IsAssignableFrom(t1) is also true.

Diese Methode kann von einer abgeleiteten Klasse überschrieben werden.This method can be overridden by a derived class.

Gilt für:

Siehe auch