Abstraction is one of the four main pillars of Object-Oriented Programming (OOP), alongside Encapsulation, Inheritance, and Polymorphism. It refers to the concept of hiding the complex implementation details of a system while exposing only the necessary parts to the user. In C#, abstraction is typically achieved using abstract classes and interfaces.
In this detailed tutorial, we'll explore the concept of abstraction in C#, provide examples with use cases, and follow up with a real-world example.
Abstraction is the process of simplifying complex systems by hiding the unnecessary details and exposing only the essential information. It helps developers focus on the "what" rather than the "how" by exposing the functionality while concealing the internal workings.
In C#, abstraction is typically implemented using:
An abstract class is a class that cannot be instantiated. It can contain abstract methods, which have no implementation in the base class and must be implemented by derived classes. An abstract class is useful when you have a base class with shared functionality but want to enforce that certain methods be overridden by any subclasses.
abstract class AbstractClass
{
public abstract void AbstractMethod(); // Abstract method, no implementation
public void NormalMethod() // Normal method with implementation
{
Console.WriteLine("This is a concrete method in the abstract class.");
}
}
// Abstract base class
abstract class Animal
{
// Abstract method (must be overridden in derived classes)
public abstract void MakeSound();
// Normal method
public void Sleep()
{
Console.WriteLine("Animal is sleeping.");
}
}
// Derived class
class Dog : Animal
{
public override void MakeSound()
{
Console.WriteLine("Dog barks.");
}
}
// Derived class
class Cat : Animal
{
public override void MakeSound()
{
Console.WriteLine("Cat meows.");
}
}
class Program
{
static void Main(string[] args)
{
Dog dog = new Dog();
dog.MakeSound(); // Output: Dog barks.
dog.Sleep(); // Output: Animal is sleeping.
Cat cat = new Cat();
cat.MakeSound(); // Output: Cat meows.
cat.Sleep(); // Output: Animal is sleeping.
}
}
An interface defines a contract that other classes must follow. It only contains method declarations without any implementation. Any class that implements the interface must provide implementations for all the methods defined in the interface.
interface IShape
{
void Draw(); // Interface method, no implementation
}
// Interface definition
interface IVehicle
{
void Start();
void Stop();
}
// Class implementing the interface
class Car : IVehicle
{
public void Start()
{
Console.WriteLine("Car started.");
}
public void Stop()
{
Console.WriteLine("Car stopped.");
}
}
// Class implementing the interface
class Bike : IVehicle
{
public void Start()
{
Console.WriteLine("Bike started.");
}
public void Stop()
{
Console.WriteLine("Bike stopped.");
}
}
class Program
{
static void Main(string[] args)
{
IVehicle car = new Car();
car.Start(); // Output: Car started.
car.Stop(); // Output: Car stopped.
IVehicle bike = new Bike();
bike.Start(); // Output: Bike started.
bike.Stop(); // Output: Bike stopped.
}
}
Let’s consider a banking system where we have different types of bank accounts, such as SavingsAccount, CurrentAccount, and LoanAccount. All of these accounts share common functionality (e.g., deposit, withdraw), but they differ in their interest calculations. We can abstract the common behavior in an abstract class and leave the specific implementation to the derived classes.
// Abstract base class
abstract class BankAccount
{
public double Balance { get; protected set; }
public void Deposit(double amount)
{
Balance += amount;
Console.WriteLine($"Deposited {amount}, New Balance: {Balance}");
}
public void Withdraw(double amount)
{
Balance -= amount;
Console.WriteLine($"Withdrew {amount}, New Balance: {Balance}");
}
// Abstract method for interest calculation
public abstract void CalculateInterest();
}
// Derived class: SavingsAccount
class SavingsAccount : BankAccount
{
public override void CalculateInterest()
{
double interest = Balance * 0.04;
Console.WriteLine($"Savings Account Interest: {interest}");
}
}
// Derived class: CurrentAccount
class CurrentAccount : BankAccount
{
public override void CalculateInterest()
{
Console.WriteLine("No interest for Current Account.");
}
}
class Program
{
static void Main(string[] args)
{
BankAccount savings = new SavingsAccount();
savings.Deposit(1000);
savings.CalculateInterest(); // Output: Savings Account Interest: 40
BankAccount current = new CurrentAccount();
current.Deposit(2000);
current.CalculateInterest(); // Output: No interest for Current Account.
}
}
BankAccount is the abstract class that provides common functionality such as Deposit and Withdraw.SavingsAccount and CurrentAccount are derived classes that implement the CalculateInterest method differently based on the type of account.In C#, abstraction is a powerful OOP principle that allows developers to manage complexity by hiding the details of how things work and focusing on what they do. This is achieved through abstract classes and interfaces, both of which provide a way to define and enforce specific behaviors without exposing the internal logic.
We explored various examples of abstraction, from simple inheritance to more complex use cases like banking systems, demonstrating how abstraction can simplify code, improve flexibility, and enhance code readability. Understanding abstraction allows developers to build scalable, maintainable applications that are easier to manage and extend in the future.