Abstract Classes and Methods in C#

This is a detailed analysis of Abstract classes and methods in C# with some concrete examples. The keyword abstract can be used with both classes and methods in C# to declare them as abstract.
 
The classes, which we can’t initialize, are known as abstract classes. They provide only partial implementations. But another class can inherit from an abstract class and can create their instances.
 
Abstract classes are one of the fundamental behaviors provided by .NET. Normally, you would like to make classes that only represent base classes, and don’t want anyone to create objects of these class types. You can make use of abstract classes to implement such functionality in C# using the modifier ‘abstract’.
 
An abstract class means that, no object of this class can be instantiated, but can make derivations of this.
 
An example of an abstract class declaration is:
 
abstract class abstractClass
{
	   //Body of abstract class
}
 
An abstract class can contain either abstract methods or non abstract methods. Abstract members do not have any implementation in the abstract class, but the same has to be provided in its derived class.
 
An example of an abstract method is:
 
abstract class abstractClass
{
  	// Abstract Method Declaration
		public abstract void abstractMethod();
}
 
Also, note that an abstract class does not mean that it should contain abstract members. Even we can have an abstract class only with non abstract members.
 
For example:
 
abstract class abstractClass
{
    	// Abstract Method	
	public abstract void abstractMethod();
	// Non-Abstract Method
	public void NonAbstractMethod()
    	{
        	Console.WriteLine("NonAbstract Method");
}

}
  
 
An example that explains abstract classes:
 
using System;

namespace abstractExample
{
      //Creating an Abstract Class
      abstract class abstractClass
      {
            //A Non abstract method
            public int AddTwoNumbers(int Num1, int Num2)
            {
                return Num1 + Num2;
            }

            //An abstract method, to be
            //overridden in derived class
            public abstract int MultiplyTwoNumbers(int Num1, int Num2);
      }

      //A Child Class of absClass
      class abstractDerived:abstractClass
      {
            [STAThread]
            static void Main(string[] args)
            {
               //You can create an
               //instance of the derived class

               abstractDerived calculate = new abstractDerived ();
               int added = calculate.AddTwoNumbers(10,20);
               int multiplied = calculate.MultiplyTwoNumbers(10,20);
               Console.WriteLine("Added : {0}, Multiplied : {1}", added, multiplied);
            }

            //using override keyword,
            //implementing the abstract method
            //MultiplyTwoNumbers
            public override int MultiplyTwoNumbers(int Num1, int Num2)
            {
                return Num1 * Num2;
            }
      }
}
 
In the above example, you can see that the abstract class abstractClass contains two methods AddTwoNumbers and MultiplyTwoNumbers. AddTwoNumbers is a non-abstract method which contains implementation and MultiplyTwoNumbers is an abstract method that does not contain implementation.
 
The class abstractDerived is derived from abstractClass and the MultiplyTwoNumbers is implemented on abstractDerived. Within the Main, an instance (calculate) of the abstractDerived is created, and calls AddTwoNumbers and MultiplyTwoNumbers.
 
You can derive an abstract class from another abstract class. In that case, in the child class it is optional to make the implementation of the abstract methods of the parent class.
 
Example:
 
//Abstract Class1
abstract class abstractClass1
{
    public abstract int AddTwoNumbers(int Num1, int Num2);
    public abstract int MultiplyTwoNumbers(int Num1, int Num2);
}

//Abstract Class2
abstract class abstractClass2 : abstractClass1
{
    //Implementing AddTwoNumbers
    public override int AddTwoNumbers(int Num1, int Num2)
    {
        return Num1+Num2;
    }
}

//Derived class from absClass2
class abstractDerived:abstractClass2
{
    //Implementing MultiplyTwoNumbers
    public override int MultiplyTwoNumbers(int Num1, int Num2)
    {
        return Num1*Num2;
    }
}
 
In the above example, abstractClass1 contains two abstract methods AddTwoNumbers and MultiplyTwoNumbers. The AddTwoNumbers is implemented in the derived class abstractClass2. The class abstractDerived is derived from abstractClass2 and the MultiplyTwoNumbers is implemented there.
 
Abstract properties
 
Here is an example of implementing abstract properties in a class.
 
//Abstract Class with abstract properties
abstract class absClass
{
    protected int myNumber;
    public abstract int numbers
    {
        get;
        set;
    }
}

class abstractDerived : abstractClass
{
    //Implementing abstract properties
    public override int numbers
    {
        get
        {
            return myNumber;
        }
        set
        {
            myNumber = value;
        }
    }
}
 
In the above example, there is a protected member declared in the abstract class. The get/set property for the member variable myNumber is defined in the derived class abstractDerived.
 
Important rules applied to abstract classes
 
An abstract class cannot be a sealed class, i.e. the following declaration is incorrect.
 
//Incorrect declaration
abstract sealed class absClass
{
}
 
Only, declarations of abstract methods are allowed in abstract classes. An abstract method cannot be private.
 
	//Incorrect declaration
	private abstract int MultiplyTwoNumbers();
 
The access modifier of the abstract method should be same in both the abstract class and its derived class. If you declare an abstract method as protected, it should be protected in its derived class. Otherwise, the compiler will raise an error.
 
An abstract method cannot have the modifier virtual, because an abstract method is implicitly virtual.
 
//Incorrect declaration
public abstract virtual int MultiplyTwoNumbers();
 
An abstract member cannot be static.
 
	//Incorrect declaration
	public abstract static int MultiplyTwoNumbers();
 
Abstract class vs. Interface
 
An abstract class can have abstract members as well as non abstract members. But in an interface all the members are implicitly abstract and all the members of the interface must override to its derived class.
 
An example of interface is:
 
interface iSampleInterface
{
  //All methods are automaticall abstract
  int AddNumbers(int Num1, int Num2);
  int MultiplyNumbers(int Num1, int Num2);
}
 
Defining an abstract class with abstract members has the same effect to defining an interface. The members of the interface are public with no implementation. Abstract classes can have protected parts, static methods, etc. A class can inherit one or more interfaces, but only one abstract class.
 
Abstract classes can add more functionality without destroying the child classes that were using the old version. In an interface, creation of additional functions will have an effect on its child classes, due to the necessary implementation of interface methods to classes.
 
The selection of interface or abstract class depends on the need and design of your project. You can make an abstract class, interface or combination of both depending on your needs.
 
Scroll to Top