Abstract in C#

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. Members marked as abstract, or included in an abstract class, must be implemented by classes that derive from the abstract class.

• 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 curly braces ({ }) following the signature. For example:  public abstract void MyMethod();

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. 

• It is an error to use the abstract modifier on a static property.
• An abstract inherited property can be overridden in a derived class by including a property declaration that uses the override modifier.

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.

abstract class WashingMachine

{

   public WashingMachine()

   {

      // Code to initialize the class goes here.

   }

   abstract public void Wash();

   abstract public void Rinse(int loadSize);

   abstract public long Spin(int speed);

}

In the above example, an abstract class is declared with one implemented

 method and three unimplemented methods. A class inheriting from this

class would have to implement the Wash, Rinse, and Spin methods. The

following example shows what the implementation of this class might look

like:

class MyWashingMachine : WashingMachine

{

   public MyWashingMachine()

   { 

      // Initialization code goes here.   

   }

   override public void Wash()

   {

      // Wash code goes here.

   }

   override public void Rinse(int loadSize)

   {

      // Rinse code goes here.

   }

   override public long Spin(int speed)

   {

      // Spin code goes here.

   }

}

When implementing an abstract class, you must implement each abstract (MustOverride)

 method in that class, and each implemented method must receive the same

 number and type of arguments, and have the same return value, as the

method specified in the abstract class.