Primary Difference Between Abstract Class and Interface in C#

Shem Otieno

In C#, what is the primary difference between an abstract class and an interface, and in what scenarios would you choose one over the other?

5 Replies

Know the answer? Post it — somebody with the same question will find it here.

Sophia Carter1y ago
Accepted answer
Absolutely! The primary difference between an abstract class and an interface in C# lies in how they define their members and provide implementation details.

1. Abstract Class:

- An abstract class can have both abstract members (methods, properties) as well as concrete members with implementations.

- It can have fields, constructors, and other members like properties and methods.

- In C#, a class can inherit only one abstract class due to the single inheritance limitation.

- Abstract classes are great when you want to provide a common base implementation for derived classes.

2. Interface:

- An interface, on the other hand, only declares the signatures of methods, properties, events, or indexers without providing any implementation details.

- A class can implement multiple interfaces in C#, allowing for flexibility in designing the class's behavior.

- Interfaces are useful when you want to define a contract that multiple classes can follow, promoting code reusability and ensuring a consistent structure.

Scenarios to Choose One over the Other:

- Use Abstract Class When:

- You want to provide a default implementation that can be shared among multiple subclasses.

- You need to define non-public members within the base class.

- You have a "is-a" relationship between the base class and derived classes.

- Use Interface When:

- You want to have a contract that multiple unrelated classes can adhere to.

- You need to support multiple inheritances in your design.

- You need to enforce a specific set of methods or properties that a class must implement.

Here's a simple example to illustrate the difference:
```
// Abstract class example
public abstract class Shape
{
    public abstract double Area(); // Abstract method
    public virtual void Print()
    {
        Console.WriteLine("Printing shape...");
    }
}

// Interface example
public interface IDrawable
{
    void Draw();
}

public class Circle : Shape, IDrawable
{
    public override double Area()
    {
        return Math.PI * radius * radius;
    }

    public void Draw()
    {
        Console.WriteLine("Drawing circle...");
    }

    private double radius;
}
```
In this example, `Shape` is an abstract class that provides a base implementation for shapes, while `IDrawable` is an interface that defines the contract for objects that can be drawn.

I hope this explanation helps clarify the primary difference between abstract classes and interfaces in C#. Feel free to ask if you have any more questions or need further clarification!
+2
Tuhin Paul1y ago

See the image above
0

Tuhin Paul1y ago

public abstract class Animal
{
    public string Name { get; set; }

    public Animal(string name)
    {
        Name = name;
    }

    public abstract void MakeSound(); // Abstract method

    public void Sleep() // Concrete method
    {
        Console.WriteLine($"{Name} is sleeping.");
    }
}

public class Dog : Animal
{
    public Dog(string name) : base(name) { }

    public override void MakeSound()
    {
        Console.WriteLine("Woof!");
    }
}

Use case: When you want to share common behavior (Sleep) and enforce specific behavior (MakeSound) among related classes.

public interface IFlyable
{
    void Fly();
}

public class Bird : IFlyable
{
    public void Fly()
    {
        Console.WriteLine("The bird is flying.");
    }
}

public class Airplane : IFlyable
{
    public void Fly()
    {
        Console.WriteLine("The airplane is flying.");
    }
}

Use case: When unrelated classes (Bird and Airplane) need to implement the same behavior (Fly).

Tuhin Paul1y ago

Primary Differences Between Abstract Classes and Interfaces

Feature	Abstract Class	Interface
Definition	A class that cannot be instantiated directly and may contain both abstract (unimplemented) and concrete (implemented) members.	A contract that defines a set of methods, properties, events, or indexers that a class must implement.
Implementation	Can provide default implementations for some methods.	Cannot provide implementations for methods (prior to C# 8.0). Starting with C# 8.0, interfaces can include default implementations.
State (Fields)	Can have fields (state).	Cannot have fields (state).
Access Modifiers	Members can have access modifiers like`public`,`protected`,`private`, etc.	Members are`public`by default and cannot have other access modifiers (except in C# 9.0+ where`init`and`private`are allowed in certain contexts).
Inheritance	A class can inherit from only one abstract class.	A class can implement multiple interfaces.
Constructor	Can have constructors to initialize state.	Cannot have constructors.
Versioning	Adding new functionality (e.g., a new method) to an abstract class is backward-compatible.	Adding new members to an interface breaks existing implementations unless default implementations are provided (C# 8.0+).
Use Case	Used when you want to share code among related classes and enforce a common base structure.	Used when you want to define a contract that unrelated classes can implement.

Matthew Hess1y ago
Hi Shem! This is a great question. Both Abstract Classes and Interfaces can be used in similar ways, but they have different advantages and purposes.

If you're familiar with C++, you may know that in C++ there is no separate, formal concept of an Interface. You only have Abstract classes. BUT, in C++ you have multiple class inheritance, so Abstract classes in C++ can function in multiple ways. C#, on the other hand, supports only single class inheritance but multiple Interface inheritance, and that's why they are used differently. Let's dig in...

Interfaces In C#, a class can implement multiple Interfaces. This makes Interfaces the preffered method for implementing polymorphism, which is the idea that a Class can be more than one thing. Consider this code:
```
public interface IDwelling
{
    bool IsPrimary { get; set; }
    int NumberOfRooms { get; set; }
}

public interface IVehicle
{
    bool IsRecreational { get; set; }
    decimal GrossWeight { get; set; }
}

public class HouseBoat : IDwelling, IVehicle
{
    // code here to implement BOTH interfaces
}

public class Program
{
    public int CountTheRecreationalVehicles(List vehicles)
    {
        int count = 0;
        vehicles.ForEach(v => { if (v.IsRecreational) count++; });
        return count;
    }
}
```
What is notable about this is that our class, HouseBoat implements both IVehicle and IDwelling. It is polymorphic. Our function that counts recreational vehicles only cares about whether the items in the list are vehicles. There might be some HouseBoats on the list, but that function just treats them as Vehicles. You can probably imagine another funcdtion that focuses on Dwellings, and a HouseBoat would work there, too.

Now, you might think this is a contrived example, but there are many real-live examples in the .NET clases. For example, List implements ICollection, IList and IEnumberable. The System.Data.Common class implements IEnumerable, IDisposable, , IDataReader, IDataRecord, and IAsyncDisposable. Note that in these cases the Interfaces are really behavior focused rather than data focused. In other words, an IEnumerable is something that you can enumerate. An IDisposable is something you can (and should) disopose of. This is probably the most common way polymorphism is used: to give a class multiple, independant behaviors.

Abstract Class - Like any base class in C#, an Abstract Class can be used to provide shared implementation for all descendant classes to use. In this way it is the same as just any class you descend from. But the specific power of the Abstract class is to shape the implementation of the descendant class by defining things the descendant must do. Consider this code example:
```
public abstract class Car
{
    public void Accelerate()
    {
        DoAccelerate();
    }

    protected abstract void DoAccelerate();
}

public class EV : Car
{
    protected override void DoAccelerate()
    {
        // run the electric motor
    }
}

public class  GasolineCar : Car
{
    protected override void DoAccelerate()
    {
        // run the internal combustion engine
    }
}
```
In this example, our base class, Car, defines a public interface with the method Accelerate. In this way, it does funcion like a formal Interface. But in also mandates that any descendant class provide an implementation of DoAccelerate. So it is structuring the implementation of descendant classes. This is a more traditional Object Oriented design and it works very well if you have layered class heirarchies where you need to defer certain kinds of code to descendant classes.

One thing I should note is that is is quite possible to use both Interfaces and Abstract classes together! I have done this frequently. I use the Interfaces to define the behaviors I want in a very clean, polymorphic way, but then I also provided Abstract Base classes that get the ball rolling and made it easy for descendant classes to implement those Interfaces.

I hope this helps! Thanks for the great question

-Matthew
@CSharpArtisan
0