C# Abstract class Vs Interface: Uses And Differences With Examples

Last updated on March 8th, 2023 at 02:53 pm

In this article, We are going to discuss the “difference between Abstract class and Interface in C#” with simple examples. This is one of the most frequently asked questions in almost every C# dot net interview.

C# Abstract class Vs Interface

In Short, An abstract class allows you to create functionality that subclasses can implement or override. An interface, on the other hand, only allows you to define functionality rather than implement it. In addition, While a class can extend only one abstract class, but can have multiple interfaces.

• The abstract class and interface are used to achieve abstractions. In C#, Abstraction is the process of defining the essential details to call methods without exposing the implementation details.
• If complex functional units are not your objective, an interface might be more appealing. Use abstract classes if you want to extend the class hierarchy in the future

Both abstract class and interface have their own advantages and disadvantages. So, without further ado, let us take a closer look at the abstract class and interface in depth.

First, Let`s take a look at the following list of differences between the abstract class and the interface.

C# Abstract class

Abstract class: In C#, An abstract class is a way to achieve abstraction, which is intended to hide the internal details and show only the functionality. An Abstract class is not allowed to be instantiated directly instead it is typically used to define a base class in the class hierarchy. It provides the common code implementation to the derived classes.

• An abstract class can have both abstract and concrete methods, So either it can be partially implemented or not implemented at all. It is mainly designed to be inherited by subclasses that either implement or override its methods.

When to use an Interface in C#?

Below is the list of reasons for using the interface in C#.

• A C# Interface allows for multiple Inheritance. A class, however, cannot inherit from more than one abstract class.
• You can achieve loose coupling by using the Interface.
• An interface can be used when you want the derived classes to fully implement all of the methods introduced in the base class.
• Abstraction can be achieved via interfaces.
• Interface Allows you to decouple a method’s definition from its inheritance hierarchy.
• An interface can be used to achieve polymorphic behavior, a single method of an Interface can have multiple redefinitions into multiple classes of unrelated types. Here, every derived class is free to provide its own implementation.
• Interfaces are best suited to achieve Dispose Pattern by defining an  IDisposable  interface.
• An Interface doesn’t contain a constructor, which helps to prevent extra roundtrip when creating an object of the derived class through the reference pointer of the interface.
• An Interface can be a great choice when we want to loop through a collection for example by using an  IEnumerable  interface.

• Your application will be easier to test and maintain if you use an interface. It helps to define a contract, or agreement, between your application and other objects. This agreement specifies the methods, fields, properties, and events an object exposes.

You should use an interface if you want a contract on some behavior or functionality to be strictly followed by the subclass or struct. If you use interfaces, you must implement all of the methods in the subclass that extends the interface.

• Interfaces may be a good choice to decouple your application’s code from specific implementations as different classes can implement methods differently.
• You can also use an interface if you want to simulate inheritance for structs because structs cannot inherit from another struct or class in C#.

When to use Abstract class Instead of Interface in C#?

This is one of the most frequently asked questions in C# dot-net interviews. Most developers are still not completely sure of the right answer. The following examples are used to illustrate these concepts.

• The Abstract classes offer default functionality for the derived classes.
• An abstract class is a great choice if you want to share a common code among several closely related classes. It acts as a base class and provides the common code implementation to the derived classes.
• An abstract class can be used to achieve versioning of the components because by adding the new functionality to the base class all the derived classes will get updated automatically. An interface on the other hand can’t be modified once created and inherited by the classes. We must create a new interface if we want to add a new method to the interface.
• You can go with the abstract class if you wanted to provide the default implementation to all the subclasses.
• The Abstract class allows code reusability.
• You can use an abstract class if we don’t want to implement all of the methods in a derived class but only some of them in a parent class.

Example of an abstract class in C#

Let’s create a simple program for an abstract class.

using System;

namespace AbstractClassDemo
{
    // Abstract class

    public abstract class Bank
    {
        // Abstract method
        public abstract void CashWithdraw(double amount);

        //field
        protected double balance;
        // Concrete method
        public void Balance()
        {
            Console.WriteLine($" Total Balance: {this.balance}");
        }
    }

    // Derived class "HsbcBank" inheriting base "Bank" class
    public class HsbcBank : Bank
    {
        // Constructor
        public HsbcBank(double amount)
        {
            this.balance = amount;
        }

        // Implementing base class method
        public override void CashWithdraw(double amount)
        {
            if (amount > this.balance)
            {
                Console.WriteLine(" Insufficient funds in bank account");
                return;
            }
            Console.WriteLine($" Withdrawing Cash ${amount} from HSBC Bank.");
            Console.WriteLine($" Remaining Balance : {this.balance - amount}");
        }
    }

    // Derived class "CityBank" inheriting base "Bank" class
    public class CityBank : Bank
    {
        // Constructor
        public CityBank(double amount)
        {
            this.balance = amount;
        }
        // Implementing base class method
        public override void CashWithdraw(double amount)
        {
            if (amount > this.balance)
            {
                Console.WriteLine(" Insufficient funds in bank account");
                return;
            }

            Console.WriteLine($" Withdrawing Cash ${amount} From City Bank.");
            Console.WriteLine($" Remaining Balance : {this.balance - amount}");
        }
    }

    class Program
    {
        static void Main()
        {
            Console.WriteLine("***** Abstract class example in C# *****");
            
            Bank bank = new HsbcBank(5000);
            bank.Balance();
            bank.CashWithdraw(300);

            Console.WriteLine();

            bank = new CityBank(10000);
            bank.Balance();
            bank.CashWithdraw(500);
           

            Console.ReadLine();
        }
    }   
}

What’s new about the interface in C# 8.0

So let’s try to explore the new features of the Interface introduced in C# 8. We will try to understand how we can use these features in our projects with simple examples.

Default Interface Methods Introduced In C# 8.0

The Default interface method which is also known as the virtual extension method is a new feature introduced in C# 8.0

It allows an Interface to add a method with implementation without breaking the existing functionality. Before C# 8 an interface was allowed to contain only (signature) the declaration part of methods, properties, events, or indexers, but now after C# 8.0 interface can contain both the declaration and the implementation.

Example of the default interface method

The following is a simple program to illustrate the concept of the default interface method in C# 8

using System;

namespace DefaultInterfaceMethodDemo
{
    // Default Interface Method In C# 8.0

    interface IDefaultInterface
    {
        // This "ShowMessage" method is having only the declaration part.    
        void ShowMessage(string text);

        // Default interface method with both declaration and definition (Implementation).
        //Now Interface members can be public, private, or protected
        public void DefaultInterfaceMethod()
        {
            Console.WriteLine("Default method of interface!");
        }
    }

    // A class that implements
    // the "IDefaultInterface" interface.
    class MyClass : IDefaultInterface
    {
        // Providing implementation
        // part of the "ShowMessage" method
        void IDefaultInterface.ShowMessage(string text)
        {
            Console.WriteLine(text);
        }
    }

    class Program
    {
        static void Main()
        {
            IDefaultInterface myClass = new MyClass();

           // Calling default interface method
            myClass.DefaultInterfaceMethod();
            myClass.ShowMessage("Hello World!");

            Console.ReadLine();
        }
    }   
}
// Output
// Default method of interface!
// Hello World!

In the above program, we can see that we have provided the implementation for the method “DefaultInterfaceMethod” in the interface itself. Here, “MyClass” does not need to implement this method.

Here, we call the “DefaultInterfaceMethod” method with the help of the “IDefaultInterface” interface reference variable. If we try to call the “DefaultInterfaceMethod” method with the class object we will get the following compile-time error.

Change the IDefaultInterface to MyClass, as shown in the below screenshot.

The above sample program produces the compile-time error because the “MyClass” does not contain a member “DefaultInterfaceMethod”.
This is proof that the inherited class “MyClass” does not know anything about the default Interface method.
The default interface methods will only work or be accessible if the class is contextually treated as an interface.

To access the default method of the interface, we must upcast the “myClass” object to the “IDefaultInterface” interface as follows.

static void Main()
        {
            MyClass myClass = new MyClass();

            //Upcasting to the interface to access the default method
           ((IDefaultInterface)myClass).DefaultInterfaceMethod();            
          
        }

// Output:
// Default method of interface!

Access Modifiers In Interface C# 8.0

Before C# 8.0, Interface members can have implicitly default public access modifier only. Modifiers like  private ,  public ,  protected ,  internal ,  virtual , and  abstract  were not allowed in an Interface.

For additional information on access modifiers in C#, see this link.

Example of Access Modifiers In An Interface

using System;

namespace AccessModifiersInInterface
{
    // Access Modifiers In Interface C# 8.0

    interface IInterface
    {
        // Default Interface method is private by default.
        private void PrivateDefaultMethod()
        {
            Console.WriteLine(" Private Default Method Of Interface!");
        }
        // Public Default Method  
        public void PublicDefaultMethod()
        {
            Console.WriteLine(" Public Default Method Of Interface!");
        }

        //Protected Default Method  
        protected void ProtectedDefaultMethod()
        {
            Console.WriteLine(" Protected Default Method Of Interface!");
        }


        //virtual method
        virtual void VirtualDefaultMethod()
        {
            Console.WriteLine(" Virtual Default method Of Interface!");
        }

        //abstract method having the only declaration

        abstract void AbstractDefaultMethod();

        // static method
        static void StaticDefaultMethod()
        {
            Console.WriteLine(" Static Default Method Of Interface!");
        }

    }

    // A class that implements
    // the "IInterface" interface.
    class MyClass : IInterface
    {
        // Providing implementation
        // part of the abstract method
        void IInterface.AbstractDefaultMethod()
        {
            Console.WriteLine(" Abstract Default Method Of Interface!");
        }

    }

    class Program
    {
        static void Main()
        {
            Console.WriteLine("***** Access Modifiers In Interface C# 8.0 *****");
            IInterface obj = new MyClass();
            //obj.PrivateDefaultMethod(); // inaccessible due to its protection level
            //obj.ProtectedDefaultMethod(); // inaccessible due to its protection level
            obj.PublicDefaultMethod();
            obj.VirtualDefaultMethod();
            obj.AbstractDefaultMethod();
            IInterface.StaticDefaultMethod();

            Console.ReadLine();
        }
    }   
}
// Output:
//*****Access Modifiers In Interface C# 8.0 *****
// Public Default Method Of Interface!
// Virtual Default method Of Interface!
// Abstract Default Method Of Interface!
// Static Default Method Of Interface!

Important Key Points About An Interface In C# 8.0

• An interface can have only the declarations part that is no longer true. After C# 8.0, the Interface can implement code for methods, properties, events, or indexers.
• In C# 8, interface members can have access modifiers such as private, public, protected, internal, virtual, abstract, override, static, and sealed.
• In C# 8, the Interface can have fields, but only if they are static.
• In C# 8, An interface can have default methods but the derived class inherited by the Interface does not know anything about the existence of the default methods also class does not contain the implementation code of the default method defined in the Interface.
• The default interface members are not inherited in the derived class in C# 8.

To learn more about Interface, please refer to this article: C# 10 new features

FAQ

References: InfoWorld- Abstract class Vs Interface

Summary:

In this article, we learned about the ‘difference between the Abstract class and Interface in C#‘ with simple examples. Also, we learned the new features in an Interface introduced in C# 8.

I hope you found this post useful in learning about Abstract class and Interface in C#. Your comments, suggestions, and constructive criticism are much appreciated.

Recommended Articles:

• Understanding Interface in C# with Examples
• SOLID Design Principles in C#: A Complete Example
• Singleton Design Pattern in C#: A Beginner’s Guide with Examples
• Top 50 C# Interview Questions and Answers For Freshers and Experienced in 2022
• Collections in C#–Queue, Stack, ArrayList, and Hashtable
• WCF vs Web API: Top 10 Differences Between WCF and Web API
• C# Array vs List: When should you use an array or a List?
• Generic Delegates in C# With Examples
• Serialization and Deserialization in C# with Example
• Sealed Class in C# with examples
• C# Enum | How to Use enumeration type in C#?
• Properties In C# with examples
• Multithreading in C#
• IEnumerable Interface in C# with examples
• C# List Class With Examples
• C# Struct vs Class
• C# Dictionary with Examples
• Fields vs Properties In C#
• Readonly vs const in C#

We would love to hear your thoughts on this post. Please leave a comment below and share it with others.

• Author
• Recent Posts

Shekh Ali

Meet Shekh Ali, a skilled Software engineer and passionate blogger with an MCA degree and 8+ years of experience in the field. He enjoys sharing his expertise in C#, Java, SQL, Design Patterns, and other related topics through his writing. When he's not coding, Shekh Ali can often indulge in his passions for reading books and fitness training.

Latest posts by Shekh Ali (see all)

• Understanding the SOLID Principle: Single Responsibility Principle in C# - June 7, 2023
• Difference between var and dynamic in C# - May 26, 2023
• Understanding the Chain of Responsibility Design Pattern in C# - May 11, 2023