Type.IsAbstract Eigenschaft

public:
 property bool IsAbstract { bool get(); };

public bool IsAbstract { get; }

member this.IsAbstract : bool

Public ReadOnly Property IsAbstract As Boolean

Eigenschaftswert

true, wenn Type abstrakt ist, andernfalls false.

Implementiert

Beispiele

Im folgenden Beispiel wird ein Array von Type -Objekten erstellt, die die folgenden Typen darstellen:contains-Typ gibt zurück true , wenn das angegebene Objekt ist abstract; andernfalls wird zurückgegeben false.

• AbstractClass, eine abstrakte Klasse (eine Klasse, die als abstract in C# und MustInherit in Visual Basic gekennzeichnet ist).

• DerivedClass, eine Klasse, die von AbstractClasserbt.

• SingleClass, eine nicht vererbbare Klasse. sie ist in C# und NotInheritable in Visual Basic definiertsealed.

• ITypeInfo, eine Schnittstelle.

• ImplementingClass, eine Klasse, die die ITypeInfo -Schnittstelle implementiert.

Die -Methode gibt nur für AbstractClass, die abstrakte Klasse und ITypeInfodie -Schnittstelle zurücktrue.

using System;

public abstract class AbstractClass
{}

public class DerivedClass : AbstractClass
{}

public sealed class SingleClass
{}

public interface ITypeInfo
{
   string GetName();
}

public class ImplementingClass : ITypeInfo
{
   public string GetName()
   {
      return this.GetType().FullName;
   }
}

delegate string InputOutput(string inp);

public class Example
{
   public static void Main()
   {
      Type[] types= { typeof(AbstractClass),
                      typeof(DerivedClass),
                      typeof(ITypeInfo),
                      typeof(SingleClass),
                      typeof(ImplementingClass),
                      typeof(InputOutput) };
      foreach (var type in types)
         Console.WriteLine("{0} is abstract: {1}",
                           type.Name, type.IsAbstract);
   }
}
// The example displays the following output:
//       AbstractClass is abstract: True
//       DerivedClass is abstract: False
//       ITypeInfo is abstract: True
//       SingleClass is abstract: False
//       ImplementingClass is abstract: False
//       InputOutput is abstract: False

[<AbstractClass>]
type AbstractClass() = class end

type DerivedClass() =  inherit AbstractClass()

[<Sealed>]
type SingleClass() = class end

type ITypeInfo =
   abstract GetName: unit -> string

type ImplementingClass() =
    interface ITypeInfo with
        member this.GetName() =
            this.GetType().FullName

type DiscriminatedUnion = 
    | Yes 
    | No of string

type Record = 
  { Name: string
    Age: int }

type InputOutput = delegate of inp: string -> string

let types = 
    [ typeof<AbstractClass>
      typeof<DerivedClass>
      typeof<ITypeInfo>
      typeof<SingleClass>
      typeof<ImplementingClass>
      typeof<DiscriminatedUnion>
      typeof<Record>
      typeof<InputOutput> ]
for typ in types do
    printfn $"{typ.Name} is abstract: {typ.IsAbstract}"

// The example displays the following output:
//       AbstractClass is abstract: True     
//       DerivedClass is abstract: False     
//       ITypeInfo is abstract: True
//       SingleClass is abstract: False      
//       ImplementingClass is abstract: False
//       DiscriminatedUnion is abstract: True
//       Record is abstract: False
//       InputOutput is abstract: False

Public MustInherit Class AbstractClass
End Class

Public Class DerivedClass : Inherits AbstractClass
End Class

Public NotInheritable Class SingleClass
End Class

Public Interface ITypeInfo
   Function GetName() As String
End Interface

Public Class ImplementingClass : Implements ITypeInfo
   Public Function GetName() As String _
          Implements ITypeInfo.GetName
      Return Me.GetType().FullName
   End Function
End Class

Delegate Function InputOutput(inp As String) As String

Module Example
   Public Sub Main()
      Dim types() As Type = { GetType(AbstractClass),
                              GetType(DerivedClass),
                              GetType(ITypeInfo),
                              GetType(SingleClass),
                              GetType(ImplementingClass),
                              GetType(InputOutput) }
      For Each type In types
         Console.WriteLine("{0} is abstract: {1}",
                           type.Name, type.IsAbstract)
      Next
   End Sub
End Module
' The example displays the following output:
'       AbstractClass is abstract: True
'       DerivedClass is abstract: False
'       ITypeInfo is abstract: True
'       SingleClass is abstract: False
'       ImplementingClass is abstract: False
'       InputOutput is abstract: False

Hinweise

Die IsAbstract -Eigenschaft gibt in den folgenden Fällen zurück true :

• Der aktuelle Typ ist abstrakt; Das heißt, sie kann nicht instanziiert werden, sondern nur als Basisklasse für abgeleitete Klassen dienen. In C# werden abstrakte Klassen mit dem abstrakten Schlüsselwort (keyword) gekennzeichnet, in F# mit dem AbstractClass-Attribut; in Visual Basic werden sie mit dem MustInherit-Schlüsselwort (keyword) gekennzeichnet.

• Der aktuelle Typ ist eine Schnittstelle.

Wenn der aktuelle einen Typparameter in der Definition eines generischen Typs oder einer generischen Type Methode darstellt, gibt diese Eigenschaft immer zurück false.

Gilt für:

Weitere Informationen

• TypeAttributes