Abstract classes vs Interfaces in .NET Core

Abstract classes vs Interfaces in .NET Core

1. Abstract Class

An abstract class serves as a base class that provides shared functionality but cannot be instantiated directly. It can contain both concrete (implemented) methods and abstract methods, which must be implemented by subclasses. Abstract classes allow for default behavior while ensuring that subclasses provide specific implementations for certain methods.

When to use an abstract class:

  • Shared functionality: For providing common functionality (methods, properties, fields) that can be reused across multiple classes.
  • Partial implementation: For default code that can be shared but still requires subclasses to implement specific details.
  • Inheritance hierarchies: For cases where a class represents a specific type of another class, and subclassing is appropriate.
  • Need for fields or constructor logic: Abstract classes can have fields, properties, and constructors, which interfaces cannot.

Example:

public abstract class Vehicle

{

    public string Model { get; set; }

 

    public void StartEngine()

    {

        Console.WriteLine("Engine started...");

    }

 

    // Abstract method - subclasses must implement this

    public abstract void Drive();

}

 

public class Car : Vehicle

{

    public override void Drive()

    {

        Console.WriteLine("Driving the car...");

    }

}

 

public class Truck : Vehicle

{

    public override void Drive()

    {

        Console.WriteLine("Driving the truck...");

    }

}

2. Interface

An interface defines a contract, specifying the methods or properties that a class must implement, but it does not provide any implementation. All methods in an interface are abstract, and it cannot have fields or provide state management. Interfaces are used to define behaviors that classes must fulfill.

When to use an interface:

  • No shared implementation: For cases where only method signatures are required, and implementation is left to the implementing classes.
  • Multiple inheritance: For situations where a class should implement multiple behaviors from different interfaces, enabling flexibility.
  • Loose coupling: For designs where classes need to be decoupled and implement various sets of behaviors.

Example:

public interface IPrintable

{

    void Print();

}

 

public interface IScanable

{

    void Scan();

}

 

public class Printer : IPrintable

{

    public void Print()

    {

        Console.WriteLine("Printing the document...");

    }

}

 

public class Scanner : IScanable

{

    public void Scan()

    {

        Console.WriteLine("Scanning the document...");

    }

}

 

public class AllInOnePrinter : IPrintable, IScanable

{

    public void Print()

    {

        Console.WriteLine("Printing the document...");

    }

 

    public void Scan()

    {

        Console.WriteLine("Scanning the document...");

    }

}

Key Differences

Feature

Abstract Class

Interface

Implementation

Can provide both implemented and abstract methods.

Can only provide method signatures (no implementation).

State

Can contain fields, properties, and constructors.

Cannot contain fields or state (only method signatures).

Multiple Inheritance

A class can only inherit one abstract class.

A class can implement multiple interfaces.

Purpose

To provide shared functionality with possible abstraction.

To define a contract that classes must implement.

Use Case

When classes share behavior, or some default implementation is needed.

When enforcing that unrelated classes adhere to the same contract.

When to Choose One Over the Other:

  • Choose an abstract class if:
    • Shared behavior is needed, and subclasses need to inherit both functionality and abstract methods.
    • A clear "is-a" relationship exists between the base class and the derived classes.
    • There is a need for fields or constructor logic that can be shared across classes.
  • Choose an interface if:
    • The focus is on defining a contract that various classes can implement.
    • Multiple, unrelated classes need to implement the same set of methods.
    • Flexibility is desired, and classes should not be restricted to a single inheritance chain.

In conclusion, abstract classes are suitable when shared functionality is needed, while interfaces are best when a contract must be defined that unrelated classes can implement. Both play important roles in object-oriented design, supporting code reusability, flexibility, and maintainability.

Comments

Post a Comment

Popular posts from this blog

Multiline to singleline IN C# - CODING

Multiline to singleline IN C# - CODING using System; using System.Linq; class Program {     static void Main(string[] args)     {         string input = @"This is                  multiline";                  // Split the input into lines, trim each line, and filter out empty lines         string result = string.Join(" ", input.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)                                                .Select(line => line.Trim()));         Console.WriteLine(result);     } } Output: This is  multiline
Read more

EF Core interview questions for beginners

1. What is Entity Framework Core (EF Core)? EF Core is an open-source Object-Relational Mapper (ORM) that enables .NET developers to work with databases using .NET objects. It allows you to interact with a database using strongly typed classes and LINQ queries, rather than writing raw SQL queries. EF Core supports various database providers, such as SQL Server, SQLite, PostgreSQL, MySQL, and more. 2. What are the advantages of using EF Core over traditional ADO.NET? Productivity:  EF Core allows you to work with databases using high-level objects, reducing the amount of boilerplate code you need to write. Cross-platform:  EF Core supports multiple databases and works on Windows, Linux, and macOS. LINQ Support:  You can query the database using LINQ, which is more type-safe and easier to maintain than raw SQL queries. Code-First & Database-First:  EF Core supports both approaches to model databases. Change Tra...
Read more

EF Core interview questions for experienced

EF Core interview questions for experienced 1. What are the main differences between Entity Framework (EF) and Entity Framework Core (EF Core)? EF Core is a complete rewrite of EF. Unlike EF, EF Core supports cross-platform development, improved performance, LINQ query translation, and has a more modular architecture. EF Core does not support all features that EF 6 does (like lazy loading and some database providers). 2. How does EF Core handle migrations, and what are some common pitfalls? EF Core uses migrations to update the database schema based on model changes. Common pitfalls include not applying migrations correctly, misalignment between model and database state, or missing/overwriting migrations during collaboration in a team environment. 3. Explain the difference between Add and Attach methods in EF Core. Add method is used to add a new entity to the context and mark it as Added , while Attach attaches an existing entity to the context with no changes. The Attach meth...
Read more