Type.IsSubclassOf(Type) Methode

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

Parameters

Retouren

trueindien de huidige Type afgeleid is van c; anders . false Deze methode retourneert false ook of c en de huidige Type gelijk zijn.

Implementeringen

Kenmerken

ComVisibleAttribute

Uitzonderingen

Voorbeelden

In het volgende voorbeeld wordt een klasse met de naam Class1 en een afgeleide klasse gemaakt met de naam DerivedC1. Hiermee wordt de IsSubclassOf methode aangeroepen om aan te geven dat DerivedC1 dit een subklasse is van 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

Opmerkingen

U kunt de IsSubclassOf methode aanroepen om een van de volgende opties te bepalen:

• Of de ene klasse is afgeleid van een andere.

• Of een type is afgeleid van ValueType. IsValueType Het is echter een efficiëntere manier om te bepalen of een type een waardetype is.

• Of een type is afgeleid van Enum. De IsEnum methode is echter een efficiëntere manier om te bepalen of een type een opsomming is.

• Of een type een gemachtigde is, dat wil gezegd, of het nu is afgeleid van of DelegateMulticastDelegate.

De IsSubclassOf methode kan niet worden gebruikt om te bepalen of een interface is afgeleid van een andere interface of of een klasse een interface implementeert. Gebruik de IsAssignableFrom methode voor dat doel, zoals in het volgende voorbeeld wordt weergegeven.

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

Als de huidige Type een typeparameter vertegenwoordigt in de definitie van een algemeen type of algemene methode, wordt deze afgeleid van de klassebeperking of van System.Object als deze geen klassebeperking heeft.

Deze methode kan worden overschreven door een afgeleide klasse.

Zie ook

• BaseType