Type.BaseType Özellik

Tanım

Ad Alanı:

System

Bütünleştirilmiş Kodlar:

netstandard.dll, System.Runtime.dll

Kaynak:

Type.cs

Geçerlinin Type doğrudan devraldığı türü alır.

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

public abstract Type? BaseType { get; }

member this.BaseType : Type

Public MustOverride ReadOnly Property BaseType As Type

Özellik Değeri

Type

Type Geçerlinin Type doğrudan devraldığı veya null geçerlinin Type sınıfı veya arabirimi temsil ettiğiObject.

Örnekler

Aşağıdaki örnekte özelliğinin kullanımı gösterilmektedir 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

Aşağıdaki örnek, bir derlemede bulunan her sınıfın tam devralma hiyerarşisini listelemek için özyineleme kullanır. Örnek, adlı C bir sınıftan türetilen adlı sınıfı Btanımlar. Bu sınıf da adlı Abir sınıftan türetilir.

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

Açıklamalar

Temel tür, geçerli türün doğrudan devraldığı türdür. Object temel türü olmayan tek türdür, bu nedenle null temel türü Objectolarak döndürülür.

Arabirimler sıfır veya daha fazla temel arabirimden devralır; bu nedenle, nesne bir arabirimi temsil ederse Type bu özellik döndürürnull. Temel arabirimler veya FindInterfacesile GetInterfaces belirlenebilir.

Geçerli Type , oluşturulmuş bir genel türü temsil ederse, temel tür genel bağımsız değişkenleri yansıtır. Örneğin, aşağıdaki bildirimleri göz önünde bulundurun:

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

(Visual Basic'te) yapı türü C<int>C(Of Integer) için BaseType özelliği döndürürB<int>.

Geçerli Type , genel tür tanımının tür parametresini temsil ederse, BaseType sınıf kısıtlamasını döndürür, yani tür parametresinin devralması gereken sınıfını döndürür. Sınıf kısıtlaması yoksa döndürür BaseTypeSystem.Object.

Bu özellik salt okunurdur.

Ayrıca bkz.

• Object
• GetInterfaces()
• FindInterfaces(TypeFilter, Object)
• UnderlyingSystemType
• IsSubclassOf(Type)
• Yansıma ve Genel Türler