Type.BaseType Propriedade

Referência

Definição

Namespace:: System

Assemblies:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Origem:: Type.CoreCLR.cs

Origem:: Type.CoreCLR.cs

Origem:: Type.CoreCLR.cs

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Obtém o tipo do qual o Type atual é herdado diretamente.

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

Valor da propriedade

Type

O Type do qual o Type atual é herdado diretamente ou null se o Type atual representar a classe Object ou uma interface.

Implementações

BaseType

Exemplos

O exemplo a seguir demonstra como usar a BaseType propriedade .

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

O exemplo a seguir usa recursão para listar a hierarquia de herança completa de cada classe encontrada em um assembly. O exemplo define uma classe chamada C que deriva de uma classe chamada B, que, por sua vez, deriva de uma classe chamada 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

Comentários

O tipo base é o tipo do qual o tipo atual herda diretamente. Object é o único tipo que não tem um tipo base, portanto null , é retornado como o tipo base de Object.

As interfaces herdam de zero ou mais interfaces base; portanto, essa propriedade retornará null se o Type objeto representar uma interface. As interfaces base podem ser determinadas com GetInterfaces ou FindInterfaces.

Se o atual Type representar um tipo genérico construído, o tipo base refletirá os argumentos genéricos. Por exemplo, considere as declarações a seguir:

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

Para o tipo C<int> construído (C(Of Integer) no Visual Basic), a BaseType propriedade retorna B<int>.

Se o atual Type representar um parâmetro de tipo de uma definição de tipo genérico, BaseType retornará a restrição de classe, ou seja, a classe que o parâmetro de tipo deve herdar. Se não houver nenhuma restrição de classe, BaseType retornará System.Object.

Esta propriedade é somente para leitura.

Aplica-se a

Produto	Versões
.NET	Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9, 10
.NET Framework	1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard	2.0, 2.1

Compartilhar via