Type.BaseType Eigenschaft

  • Referenz

Definition

Namespace:
System
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll
Source:
Type.CoreCLR.cs
Source:
Type.CoreCLR.cs
Source:
Type.CoreCLR.cs

Ruft den Typ ab, von dem der aktuelle Type direkt vererbt wird.

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

Eigenschaftswert

Type

Der Type, von dem der aktuelle Type direkt erbt, oder null, wenn der aktuelle Type die Object-Klasse oder eine Schnittstelle darstellt.

Implementiert

BaseType

Beispiele

Im folgenden Beispiel wird die Verwendung der BaseType -Eigenschaft veranschaulicht.

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

Im folgenden Beispiel wird die Rekursion verwendet, um die vollständige Vererbungshierarchie jeder Klasse in einer Assembly auflisten zu können. Im Beispiel wird eine Klasse namens C definiert, die von einer Klasse mit dem Namen Babgeleitet wird, die wiederum von einer Klasse namens Aabgeleitet wird.

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

Hinweise

Der Basistyp ist der Typ, von dem der aktuelle Typ direkt erbt. Object ist der einzige Typ, der keinen Basistyp aufweist, daher null wird als Basistyp von Objectzurückgegeben.

Schnittstellen erben von null oder mehr Basisschnittstellen; Daher gibt diese Eigenschaft zurück null , wenn das Type -Objekt eine Schnittstelle darstellt. Die Basisschnittstellen können mit GetInterfaces oder FindInterfacesbestimmt werden.

Wenn der aktuelle einen konstruierten generischen Type Typ darstellt, spiegelt der Basistyp die generischen Argumente wider. Betrachten Sie beispielsweise die folgenden Deklarationen:

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

Für den konstruierten Typ C<int> (C(Of Integer) in Visual Basic) gibt die BaseType -Eigenschaft zurück B<int>.

Wenn der aktuelle einen Typparameter einer generischen Typdefinition darstellt, BaseType gibt die Klasseneinschränkung zurück, d. h. die Klasse, die der Typparameter erben Type muss. Wenn keine Klasseneinschränkung vorhanden ist, BaseType wird zurückgegeben System.Object.

Diese Eigenschaft ist schreibgeschützt.

Gilt für:

Weitere Informationen