Abstract

The abstract modifier can be used with classes, methods, properties, indexers, and events.

Use the abstract modifier in a class declaration to indicate that a class is intended only to be a base class of other classes.

Abstract classes have the following features:

• An abstract class cannot be instantiated.
• An abstract class may contain abstract methods and accessors.
• It is not possible to modify an abstract class with the sealed modifier, which means that the class cannot be inherited.
• A non-abstract class derived from an abstract class must include actual implementations of all inherited abstract methods and accessors.

Use the abstract modifier in a method or property declaration to indicate that the method or property does not contain implementation.

Abstract methods have the following features:

• An abstract method is implicitly a virtual method.
• Abstract method declarations are only permitted in abstract classes.
• Because an abstract method declaration provides no actual implementation, there is no method body; the method declaration simply ends with a semicolon and there are no braces ({ }) following the signature. For example:

·         The implementation is provided by an overriding method, which is a member of a non-abstract class.

•  It is an error to use the static or virtual modifiers in an abstract method declaration.

public abstract void MyMethod();

An abstract class must provide implementation for all interface members.
An abstract class that implements an interface might map the interface methods onto abstract methods. For example:

interface I

{

    void M();

}

abstract class C : I

{

    public abstract void M();

}

Example

In this example, the class MyDerivedC is derived from an abstract class MyBaseC. The abstract class contains an abstract method, MyMethod(), and two abstract properties, GetX() and GetY().

// abstract_keyword.cs

// Abstract Classes

using System;

abstract class MyBaseC   // Abstract class

{

   protected int x = 100;

   protected int y = 150;

   public abstract void MyMethod();   // Abstract method

   public abstract int GetX   // Abstract property

   {

      get;

   }

   public abstract int GetY   // Abstract property

   {

      get;

   }

}

class MyDerivedC: MyBaseC

{

   public override void MyMethod()

   {

      x++;

      y++;  

   }  

   public override int GetX   // overriding property

   {

      get

      {

         return x+10;

      }

   }

   public override int GetY   // overriding property

   {

      get

      {

         return y+10;

      }

   }

   public static void Main()

   {

      MyDerivedC mC = new MyDerivedC();

      mC.MyMethod();

      Console.WriteLine("x = {0}, y = {1}", mC.GetX, mC.GetY);   

   }

}

Output

x = 111, y = 161

In the preceding example, if you attempt to instantiate the abstract class by using a statement like this:

MyBaseC mC1 = new MyBaseC();   // Error

you will get the following error message:

Cannot create an instance of the abstract class 'MyBaseC'.