Sdílet prostřednictvím

Type.BaseType Vlastnost

  • Reference

Definice

Obor názvů:
System
Sestavení:
System.Runtime.dll
Sestavení:
mscorlib.dll
Sestavení:
netstandard.dll
Zdroj:
Type.CoreCLR.cs
Zdroj:
Type.CoreCLR.cs
Zdroj:
Type.CoreCLR.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; }
public abstract Type BaseType { get; }
member this.BaseType : Type
Public MustOverride ReadOnly Property BaseType As Type

Hodnota vlastnosti

Type

, Type ze kterého aktuální Type přímo dědí, nebo null pokud aktuální Type představuje Object třídu nebo rozhraní.

Implementuje

BaseType

Příklady

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

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

Následující příklad používá rekurze k výpisu úplné hierarchie dědičnosti 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á je zase odvozena z 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í. Objectje jediný typ, který nemá základní typ, a 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 konstruovaný obecný typ, základní typ odráží obecné argumenty. Představte si například následující deklarace:

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

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

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

Tato vlastnost je jen ke čtení.

Platí pro

Viz také