Type.IsSubclassOf(Type) Metodo

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

Parametri

Restituisce

Boolean

true se l'oggetto Type corrente deriva da c; in caso contrario, false. Questo metodo restituisce anche false se c e l'oggetto Type corrente sono uguali.

Implementazioni

Attributi

ComVisibleAttribute

Eccezioni

Esempio

Nell'esempio seguente viene creata una classe Class1 denominata e una classe derivata denominata DerivedC1 . Chiama il metodo IsSubclassOf per mostrare che è una DerivedC1 sottoclasse di 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

Commenti

È possibile chiamare il IsSubclassOf metodo per determinare uno degli elementi seguenti:

• Indica se una classe deriva da un'altra.

• Indica se un tipo deriva da ValueType . Tuttavia, IsValueType è un modo più efficiente per determinare se un tipo è un tipo valore.

• Indica se un tipo deriva da Enum . Tuttavia, il IsEnum metodo è un modo più efficiente per determinare se un tipo è un'enumerazione.

• Indica se un tipo è un delegato, ad esempio se deriva da Delegate o MulticastDelegate .

Il metodo non può essere usato per determinare se un'interfaccia deriva da un'altra interfaccia o IsSubclassOf se una classe implementa un'interfaccia. Usare il IsAssignableFrom metodo a tale scopo, come illustrato nell'esempio seguente.

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

Se l'oggetto corrente rappresenta un parametro di tipo nella definizione di un tipo o di un metodo generico, deriva dal vincolo di classe o da se non Type dispone di alcun vincolo di System.Object classe.

Questo metodo può essere sottoposto a override da una classe derivata.

Si applica a

Vedi anche

• BaseType