Type.BaseType Vlastnost

Definice

Obor názvů:

System

Sestavení:

netstandard.dll, System.Runtime.dll

Zdroj:

Type.cs

Získá typ, ze kterého aktuální Type přímo dědí.

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

public abstract Type? BaseType { get; }

member this.BaseType : Type

Public MustOverride ReadOnly Property BaseType As Type

Hodnota vlastnosti

Type

Z Type nichž aktuální Type přímo dědí, nebo null pokud aktuální Type představuje Object třídu nebo rozhraní.

Příklady

Následující příklad ukazuje použití BaseType vlastnosti.

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

Následující příklad používá rekurze k výpisu úplné dědičnosti hierarchie každé třídy nalezené v sestavení. Příklad definuje třídu s názvem C , která je odvozena od třídy s názvem B, která se následně odvozuje od třídy s názvem 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

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

Poznámky

Základní typ je typ, ze kterého aktuální typ přímo dědí. Object je jediný typ, který nemá základní typ, proto null je vrácen jako základní typ Object.

Rozhraní dědí z nuly nebo více základních rozhraní; proto tato vlastnost vrátí null , pokud Type objekt představuje rozhraní. Základní rozhraní lze určit pomocí GetInterfaces nebo FindInterfaces.

Pokud aktuální Type představuje vytvořený obecný typ, základní typ odráží obecné argumenty. Představte si například následující deklarace:

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

Pro konstruovaný typ C<int> (C(Of Integer) v jazyce Visual Basic) BaseType vrátí B<int>vlastnost .

Pokud aktuální Type představuje parametr typu definice obecného typu, BaseType vrátí omezení třídy, tj. třída, která musí parametr typu dědit. Pokud neexistuje žádné omezení třídy, BaseType vrátí hodnotu System.Object.

Tato vlastnost je jen ke čtení.

Viz také

• Object
• GetInterfaces()
• FindInterfaces(TypeFilter, Object)
• UnderlyingSystemType
• IsSubclassOf(Type)
• Reflexe a generické typy