Type.IsAbstract Type.IsAbstract Type.IsAbstract Type.IsAbstract Property

Definition

Ruft einen Wert ab, der angibt, ob der Type abstrakt ist und überschrieben werden muss.Gets a value indicating whether the Type is abstract and must be overridden.

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.true if the Type is abstract; otherwise, false.

Implementiert

Beispiele

Im folgenden Beispiel wird ein Array von Type -Objekten erstellt, die die folgenden Typen darstellen: true enthält Rückgabe Typen, wenn abstractdas angegebene Objekt ist, falseandernfalls wird zurückgegeben.The following example creates an array of Type objects that represent the following types:contains type returns true if the specified object is abstract; otherwise, it returns false.

  • AbstractClass, eine abstrakte Klasse (eine Klasse, die abstract als C# in MustInherit und in Visual Basic gekennzeichnet ist).AbstractClass, an abstract class (a class marked as abstract in C# and MustInherit in Visual Basic).

  • DerivedClass, eine Klasse, die von AbstractClasserbt.DerivedClass, a class that inherits from AbstractClass.

  • SingleClass, eine nicht vererbbare Klasse.SingleClass, a non-inheritable class. Sie wird als sealed in C# und NotInheritable in Visual Basic definiert.It is defined as sealed in C# and NotInheritable in Visual Basic.

  • ITypeInfo, eine-Schnittstelle.ITypeInfo, an interface.

  • ImplementingClass, eine Klasse, die die ITypeInfo -Schnittstelle implementiert.ImplementingClass, a class that implements the ITypeInfo interface.

Die-Methode true gibt nur AbstractClassfür die-Schnittstelle, ITypeInfodie abstrakte-Klasse und die-Schnittstelle zurück.The method returns true only for AbstractClass, the abstract class, and ITypeInfo, the interface.

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
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 true wird in den folgenden Fällen zurückgegeben:The IsAbstract property returns true in the following cases:

  • Der aktuelle Typ ist abstrakt. Das heißt, dass es nicht instanziiert werden kann, sondern nur als Basisklasse für abgeleitete Klassen fungieren kann.The current type is abstract; that is, it cannot be instantiated, but can only serve as the base class for derived classes. In C#werden abstrakte Klassen mit dem abstract -Schlüsselwort gekennzeichnet. in Visual Basic sind Sie mit dem MustInherit -Schlüsselwort gekennzeichnet.In C#, abstract classes are marked with the abstract keyword; in Visual Basic, they are marked with the MustInherit keyword.

  • Der aktuelle Typ ist eine Schnittstelle.The current type is an interface.

Wenn der aktuelle Type einen Typparameter in der Definition eines generischen Typs oder einer generischen Methode darstellt, gibt diese falseEigenschaft immer zurück.If the current Type represents a type parameter in the definition of a generic type or generic method, this property always returns false.

Gilt für:

Siehe auch