Type.BaseType Egenskap

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

Egenskapsvärde

Från Type vilken den aktuella ärver Type direkt, eller null om den aktuella Type representerar Object klassen eller ett gränssnitt.

Implementeringar

Exempel

I följande exempel visas hur du använder egenskapen 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

I följande exempel används rekursion för att lista den fullständiga arvshierarkin för varje klass som finns i en sammansättning. Exemplet definierar en klass med namnet C som härleds från en klass med namnet B, som i sin tur härleds från en klass med namnet 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

Kommentarer

Bastypen är den typ som den aktuella typen ärver direkt från. Object är den enda typen som inte har någon bastyp. Därför null returneras den som bastypen Objectför .

Gränssnitt ärver från noll eller fler basgränssnitt. Därför returnerar null den här egenskapen om objektet Type representerar ett gränssnitt. Basgränssnitten kan fastställas med GetInterfaces eller FindInterfaces.

Om strömmen Type representerar en konstruerad allmän typ återspeglar bastypen de allmänna argumenten. Tänk till exempel på följande deklarationer:

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

För den konstruerade typen C<int> (C(Of Integer) i Visual Basic) returnerar egenskapen BaseTypeB<int>.

Om den aktuella Type representerar en typparameter av en allmän typdefinition BaseType returnerar klassvillkoret, det vill s.v.s. den klass som typparametern måste ärva. Om det inte finns någon klassbegränsning BaseType returnerar System.Object.

Den här egenskapen är skrivskyddad.

Se även

• Object
• GetInterfaces()
• FindInterfaces(TypeFilter, Object)
• UnderlyingSystemType
• IsSubclassOf(Type)
• Reflektion och generiska typer