Type.BaseType Type.BaseType Type.BaseType Type.BaseType Property

Definizione

Ottiene il tipo da cui l'oggetto Type corrente eredita direttamente.Gets the type from which the current Type directly inherits.

public:
 abstract property Type ^ BaseType { Type ^ get(); };
public abstract Type BaseType { get; }
member this.BaseType : Type
Public MustOverride ReadOnly Property BaseType As Type

Valore della proprietà

Oggetto Type da cui Type corrente eredita direttamente o null se Type rappresenta la classe Object o un'interfaccia.The Type from which the current Type directly inherits, or null if the current Type represents the Object class or an interface.

Implementazioni

Esempi

Nell'esempio seguente viene illustrato l' BaseType utilizzo della proprietà.The following example demonstrates using the BaseType property.

using namespace System;
void main()
{
   Type^ t = int::typeid;
   Console::WriteLine( "{0} inherits from {1}.", t, t->BaseType );
}

using System;
class TestType 
{
    public static void Main() 
    {
        Type t = typeof(int);
        Console.WriteLine("{0} inherits from {1}.", t,t.BaseType);
    }
}
Class TestType
   
    Public Shared Sub Main()
        Dim t As Type = GetType(Integer)
        Console.WriteLine("{0} inherits from {1}.", t, t.BaseType)
    End Sub
End Class 'TestType

Nell'esempio seguente viene utilizzata la ricorsione per elencare la gerarchia di ereditarietà completa di ogni classe trovata in un assembly.The following example uses recursion to list the complete inheritance hierarchy of each class found in an assembly. Nell'esempio viene definita una classe C denominata che deriva da una classe denominata B, che a sua volta deriva da una classe denominata A.The example defines a class named C that derives from a class named B, which, in turn, derives from a class named A.

using System;

public class Example
{
   public static void Main()
   {
      foreach (var t in typeof(Example).Assembly.GetTypes()) {
         Console.WriteLine("{0} derived from: ", t.FullName);
         var derived = t;
         do { 
            derived = derived.BaseType;
            if (derived != null) 
               Console.WriteLine("   {0}", derived.FullName);

         } while (derived != null);
         Console.WriteLine(); 
      } 
   }
}

public class A {} 

public class B : A
{}

public class C : B   
{}
// The example displays the following output:
//       Example derived from:
//          System.Object
//       
//       A derived from:
//          System.Object
//       
//       B derived from:
//          A
//          System.Object
//       
//       C derived from:
//          B
//          A
//          System.Object
Public Class Example
   Public Shared Sub Main()
      For Each t In GetType(Example).Assembly.GetTypes()
         Console.WriteLine("{0} derived from: ", t.FullName)
         Dim derived As Type = t
         Do 
            derived = derived.BaseType
            If derived IsNot Nothing Then 
               Console.WriteLine("   {0}", derived.FullName)
            End If   
         Loop While derived IsNot Nothing
         Console.WriteLine() 
      Next 
   End Sub
End Class

Public Class A 
End Class

Public Class B : Inherits A
End Class

Public Class C : Inherits B
End Class
' The example displays the following output:
'       Example derived from:
'          System.Object
'       
'       A derived from:
'          System.Object
'       
'       B derived from:
'          A
'          System.Object
'       
'       C derived from:
'          B
'          A
'          System.Object

Commenti

Il tipo di base è il tipo da cui il tipo corrente eredita direttamente.The base type is the type from which the current type directly inherits. Objectè l'unico tipo che non ha un tipo di base, pertanto null viene restituito come tipo di base di Object.Object is the only type that does not have a base type, therefore null is returned as the base type of Object.

Le interfacce ereditano da zero o più interfacce di base; Pertanto, questa proprietà restituisce null se l' Type oggetto rappresenta un'interfaccia.Interfaces inherit from zero or more base interfaces; therefore, this property returns null if the Type object represents an interface. Le interfacce di base possono essere determinate GetInterfaces con FindInterfaceso.The base interfaces can be determined with GetInterfaces or FindInterfaces.

Se l'oggetto Type corrente rappresenta un tipo generico costruito, il tipo di base riflette gli argomenti generici.If the current Type represents a constructed generic type, the base type reflects the generic arguments. Si considerino ad esempio le dichiarazioni seguenti:For example, consider the following declarations:

generic<typename U> ref class B { };
generic<typename T> ref class C : B<T> { };
class B<U> { }
class C<T> : B<T> { }
Class B(Of U)
End Class
Class C(Of T)
    Inherits B(Of T)
End Class

Per il tipo C<int> costruito (C(Of Integer) in Visual Basic), la BaseType proprietà restituisce B<int>.For the constructed type C<int> (C(Of Integer) in Visual Basic), the BaseType property returns B<int>.

Se l'oggetto Type corrente rappresenta un parametro di tipo di una definizione di BaseType tipo generico, restituisce il vincolo di classe, ovvero la classe che deve essere ereditata dal parametro di tipo.If the current Type represents a type parameter of a generic type definition, BaseType returns the class constraint, that is, the class the type parameter must inherit. Se non è presente alcun vincolo di BaseType classe System.Object, restituisce.If there is no class constraint, BaseType returns System.Object.

Questa proprietà è di sola lettura.This property is read-only.

Si applica a

Vedi anche