Type.IsAbstract Özellik

Tanım

Ad Alanı:

System

Bütünleştirilmiş Kod:

System.Runtime.dll

Kaynak:

Type.cs

soyut olup olmadığını Type ve geçersiz kılınması gerektiğini belirten bir değer alır.

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

public bool IsAbstract { get; }

member this.IsAbstract : bool

Public ReadOnly Property IsAbstract As Boolean

Özellik Değeri

Boolean

true Type soyutsa; değilse, false.

Örnekler

Aşağıdaki örnek, aşağıdaki türleri temsil eden bir nesne dizisi Type oluşturur:belirtilen nesne abstractise tür döndürürtrue; aksi takdirde döndürürfalse.

• AbstractClass, bir soyut sınıf (C# ve MustInherit Visual Basic'te olarak abstract işaretlenmiş bir sınıf).

• DerivedClass, öğesinden AbstractClassdevralan bir sınıf.

• SingleClass, devralınamaz bir sınıf. C# ve NotInheritable Visual Basic'te olarak sealed tanımlanır.

• ITypeInfo, bir arabirim.

• ImplementingClass, arabirimini ITypeInfo uygulayan bir sınıf.

yöntemi yalnızca , soyut sınıfı ve ITypeInfoarabirimi için AbstractClassdöndürürtrue.

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

Açıklamalar

IsAbstract özelliği aşağıdaki durumlarda döndürürtrue:

• Geçerli tür soyut; örneğinin örneği oluşturulamaz, ancak yalnızca türetilmiş sınıflar için temel sınıf olarak görev yapabilir. C# dilinde soyut sınıflar abstract anahtar sözcüğüyle işaretlenir; F# dilinde AbstractClass özniteliğiyle işaretlenir; Visual Basic'te MustInherit anahtar sözcüğüyle işaretlenir.

• Geçerli tür bir arabirimdir.

Geçerli Type , genel bir türün veya genel yöntemin tanımındaki bir tür parametresini temsil ederse, bu özellik her zaman döndürür false.

Ayrıca bkz.

• TypeAttributes