Type.BaseType Proprietà

public:
 abstract property Type ^ BaseType { Type ^ get(); };

public abstract Type? BaseType { 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.

Implementazioni

Esempio

Nell'esempio seguente viene illustrato l'uso della BaseType proprietà .

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);
    }
}

let t = typeof<int>
printfn $"{t} inherits from {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

Nell'esempio seguente viene usata la ricorsione per elencare la gerarchia di ereditarietà completa di ogni classe trovata in un assembly. L'esempio definisce una classe denominata C che deriva da una classe denominata , che, a sua volta, deriva da una classe denominata BA.

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

type A() = class end 

type B() = inherit A()

type C() = inherit B()   

module Example =
    [<EntryPoint>]
    let main _ =
        for t in typeof<A>.Assembly.GetTypes() do
            printfn $"{t.FullName} derived from: "
            let mutable derived = t
            while derived <> null do
                derived <- derived.BaseType
                if derived <> null then 
                    printfn $"   {derived.FullName}"
            printfn ""
        0
// 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. Object è l'unico tipo che non ha un tipo di base, pertanto null viene restituito come tipo di base di Object.

Le interfacce ereditano da zero o più interfacce di base; pertanto, questa proprietà restituisce null se l'oggetto rappresenta un'interfaccia Type . Le interfacce di base possono essere determinate con GetInterfaces o FindInterfaces.

Se l'oggetto corrente Type rappresenta un tipo generico costruito, il tipo di base riflette gli argomenti generici. Si considerino ad esempio le dichiarazioni seguenti:

generic<typename U> ref class B { };
generic<typename T> ref class C : B<T> { };

class B<U> { }
class C<T> : B<T> { }

type B<'U>() = class end
type C<'T>() = inherit 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>.

Se l'oggetto corrente Type rappresenta un parametro di tipo di una definizione di tipo generico, BaseType restituisce il vincolo di classe, ovvero la classe che il parametro di tipo deve ereditare. Se non esiste alcun vincolo di classe, BaseType restituisce System.Object.

Questa proprietà è di sola lettura.

Si applica a

Vedi anche

• Object
• GetInterfaces()
• FindInterfaces(TypeFilter, Object)
• UnderlyingSystemType
• IsSubclassOf(Type)
• Reflection e tipi generici