Abstract vs Interfaces in dotnet Framework

Abstract Class vs Interface in .NET

Both are used for abstraction, but they solve different problems. Here's the simple breakdown:

Abstract Class

• Represents an "IS-A" relationship

• Can have both implemented and unimplemented (abstract) methods

• Can have fields, constructors, and access modifiers (private/protected)

• A class can inherit only one abstract class

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

    public void MarkAttendance() // implemented, shared logic
    {
        Console.WriteLine($"{Name} marked present.");
    }

    public abstract decimal CalculateSalary(); // must be implemented by child
}

public class Developer : Employee
{
    public override decimal CalculateSalary() => 50000;
}

Interface

• Represents a "CAN-DO" capability/contract

• No implementation (until default interface methods in C# 8+, but rarely used that way)

• No fields, members are implicitly public

• A class can implement multiple interfaces

public interface IPayable
{
    decimal CalculateSalary();
}

public class Developer : Employee, IPayable
{
    public decimal CalculateSalary() => 50000;
}

Quick way to decide which to use:

• If classes share common state/behavior and are naturally related ? Abstract class

• If unrelated classes just need to guarantee the same behavior ? Interface

Abstract Class

• Can have implemented methods, fields, and constructors.
• Supports inheritance (only one abstract/base class allowed).
• Used when classes share common behavior and implementation.
• Can have access modifiers.

Interface

• Only contains method signatures (until C# 8, where default implementations are now allowed).
• Supports multiple inheritance (a class can implement multiple interfaces).
• Used when you want to define a contract without any implementation.
• All members are public by default.

Abstract Classes:    
An abstract class is a class that cannot be instantiated on its own and may contain both abstract methods (without implementation) and non-abstract methods (with implementation). It is used when you want to provide a common base class with default behavior, while still forcing derived classes to override certain members.
Key Characteristics:

• Can contain method implementations.
• Can have fields, constructors, access modifiers, and static members.
• Supports inheritance (single inheritance only).
• Allows both abstract and concrete methods.
• Useful when shared code is needed among derived classes.

Interfaces:
An interface defines a contract that classes must follow. It only contains method, property, event, or indexer declarations (in older versions of .NET; later versions allow default implementations). It is used when you want to define a contract that multiple unrelated classes can implement.
Key Characteristics:

• Cannot contain fields or constructors (pre-C# 8.0).
• No implementation (pre-C# 8.0); only method signatures.
• Allows multiple inheritance.
• Promotes loose coupling and supports dependency injection patterns.
• Members are public by default and cannot have access modifiers

When to Use Which?

• Use Abstract Class when:
  • You need to provide default behavior.
  • You want to share common implementation among related classes.
• Use Interface when:
  • You need to define a contract that multiple unrelated classes can implement.
  • You want to support multiple inheritance.