Adapter Pattern in C# – Real-Time Example (Compatibility Between Systems)

What is Adapter Pattern?

The Adapter Pattern is a structural design pattern that converts one interface into another compatible interface so that incompatible classes can work together.

It acts like a bridge or translator between two systems.

Why Use Adapter Pattern?

  • Integrate third-party APIs easily
  • Reuse legacy code
  • Avoid modifying existing systems
  • Standardize external integrations

Real-Time Scenario

Suppose your application expects: 

IPayment.Pay()

But a third-party provider gives: 

MakePayment()

👉 Interfaces are different
👉 Adapter solves this compatibility issue

Real-Time Example – Payment Gateway Integration

Step 1: Target Interface (Expected by System)

public interface IPayment
{
    void Pay(decimal amount);
}

Step 2: Third-Party Service (Incompatible Interface)

public class ThirdPartyPaymentGateway
{
    public void MakePayment(decimal amount)
    {
        Console.WriteLine($"Paid {amount} using third-party gateway");
    }
}

Step 3: Adapter Class

public class PaymentAdapter : IPayment
{
    private readonly ThirdPartyPaymentGateway _gateway;

    public PaymentAdapter(ThirdPartyPaymentGateway gateway)
    {
        _gateway = gateway;
    }

    public void Pay(decimal amount)
    {
        _gateway.MakePayment(amount);
    }
}

Usage Example

IPayment payment = new PaymentAdapter(
    new ThirdPartyPaymentGateway()
);

payment.Pay(1000);

Output

Paid 1000 using third-party gateway

Key Concept

Instead of changing third-party code ❌
We adapt it ✔ 

payment.Pay(1000);

// internally converted to
_gateway.MakePayment(1000);

Diagram Understanding

Client
   ↓
IPayment
   ↓
PaymentAdapter
   ↓
ThirdPartyPaymentGateway

👉 Adapter translates communication

Advantages

  • ✔ Reuse existing systems
  • ✔ No modification of third-party code
  • ✔ Improves flexibility
  • ✔ Reduces coupling
  • ✔ Easy integration of external APIs

Disadvantages

  • ✖ Adds extra abstraction layer
  • ✖ More classes introduced
  • ✖ Can increase complexity if overused

When to Use

Use Adapter Pattern when:

  • Integrating third-party libraries
  • Working with legacy systems
  • Interfaces are incompatible
  • You cannot modify external code

Real Project Mapping (.NET + Angular)

Feature Usage
Payment gateway integration Adapter
External REST APIs Adapter
Legacy ERP integration Adapter
Vendor SDK integration Adapter

Advanced .NET Example

Using Multiple Providers

public class RazorpayAdapter : IPayment
{
    public void Pay(decimal amount)
    {
        Console.WriteLine("Razorpay Payment");
    }
}

public class StripeAdapter : IPayment
{
    public void Pay(decimal amount)
    {
        Console.WriteLine("Stripe Payment");
    }
}

👉 Easily switch providers without changing business logic

Pro Tip

Combine:

  • Adapter + Factory Pattern
  • Adapter + Dependency Injection

For scalable enterprise applications.

Summary

Adapter Pattern helps you:

  • Connect incompatible systems
  • Integrate third-party services cleanly
  • Reuse legacy code efficiently

👉 Perfect for:

  • Payment gateways
  • External APIs
  • Legacy integrations
  • Multi-provider systems

Comments

Post a Comment

Popular posts from this blog

Promises in Angular

🚀 Promises in Angular – The Complete Beginner’s Guide (with Examples) 📘 Introduction In modern Angular development, handling asynchronous operations is essential. Whether you're fetching data from an API, loading files, or wrapping browser-native APIs, Promises offer a clean and readable way to deal with one-time asynchronous operations. This guide explains: What Promises are How they compare with Observables Real-world examples using .then() and async/await When to use Promises vs Observables in Angular 📚 Table of Contents 🔍 What is a Promise? 🔁 Promise Lifecycle ✨ Key Features 📌 Syntax 💻 Example 1: Fetch 💻 Example 2: setTimeout 📊 Promises vs Observables 🎯 When to Use Promises 📦 Angular Service Example 🔄 Observable vs Promise ❓ FAQ ✅ Summary 🔍 What is a Promise? A Promise is a JavaScript object that represents the eventual success (fulfilled) or failure (rejected) of an asynchronous operation. 📌 Com...
Read more

Debouncing & Throttling in RxJS: Optimizing API Calls and User Interactions

RxJS Debounce vs Throttle in Angular – Best Practices & Examples What is RxJS — quick primer RxJS (Reactive Extensions for JavaScript) provides Observables and operators to model and manipulate streams of asynchronous events — from keystrokes and HTTP requests to timers and WebSocket messages. 💡 Why this matters: Operators like debounceTime and throttleTime help you control event frequency, reducing wasted CPU and network work while improving UX. 1. Debouncing — emit after silence Debouncing delays emitting a value until a specified period of inactivity. It's best for typeahead inputs where only the final value after the user stops typing is relevant. Live search example (production-ready) // search.component.ts import { Component, OnDestroy } from '@angular/core'; import { FormControl } from '@angular/forms'; import { Subject } from 'rxjs'; import { debounc...
Read more

Csharp Coding - Session

Image
✅ Reverse String Array using System; public class Program { public static void Main() { ReverseStringArray (); } public static void ReverseStringArray() { string[] str = { "priya", "Sai" }; int length = str.Length; for (int i = 0, j = length - 1; i < j; i++, j--) { string temp = str[i]; str[i] = str[j]; str[j] = temp; } Console.WriteLine(string.Join(", ", str)); // Output: Sai, priya } } Output: Sai, priya ✅ Reverse String Array + Each Word using System; public class Program { public static void Main() { ReverseStringArray(); } public static void ReverseStringArray() { string[] str = { "priya", "Sai" }; // Step 1: Reverse the array string[] reversedArray = ReverseArray (str); // Step 2: Reverse e...
Read more