C# ఇంటర్‌ఫేసెస్, అబ్‌స్ట్రాక్ట్ క్లాసెస్ & C# Records (Immutable Data)

⚡ Modern C# 12 / .NET 8 LTS 📖 Chapter 16 of 20 🏛️ Phase 04: ఆబ్జెక్ట్ ఓరియెంటెడ్ ప్రోగ్రామింగ్ (OOP) 📅 2026 Academic Edition
📌 Covered in this chapter: అబ్‌స్ట్రాక్షన్ సిద్ధాంతం · abstract క్లాసెస్ & abstract మెథడ్స్ · interfaces ప్యూర్ కాంట్రాక్ట్స్ · Abstract Class vs Interface సమగ్ర పోలిక · బహుళ ఇంటర్‌ఫేస్ ఇంప్లిమెంటేషన్ & Explicit Interface Implementation · C# 8+ Default Interface Methods · లూజ్ కప్లింగ్ & డిపెండెన్సీ ఇంజెక్షన్ (DI) పునాది · C# 9+ record class విప్లవం · Value-based Equality vs Reference Equality · with నాన్-డిస్ట్రక్టివ్ మ్యుటేషన్ · record struct · ఎంటర్‌ప్రైజ్ ఈ-కామర్స్ ఆర్డర్ ప్రాసెసింగ్ ఇంజిన్ · 5 ఇంటరాక్టివ్ క్విజ్ ప్రశ్నలు

Phase 04 గ్రాండ్ ఫినాలే: అబ్‌స్ట్రాక్షన్ & ఆధునిక C# Records! 🏛️

ఒక ఇంజనీర్ పవర్ సాకెట్‌ను డిజైన్ చేసినప్పుడు, ఆ సాకెట్‌లో టీవీ పెడతారా, ఫ్రిజ్ పెడతారా లేదా ల్యాప్‌టాప్ ఛార్జర్ పెడతారా అనేది సాకెట్‌కు ముఖ్యం కాదు. ఆ సాకెట్ ఒకే ఒక కాంట్రాక్ట్ (Contract) ను మాత్రమే డిమాండ్ చేస్తుంది: "230 వోల్ట్స్, 3-పిన్ ప్లగ్ ఉంటే చాలు, కరెంట్ సరఫరా అవుతుంది!".

సాఫ్ట్‌వేర్ ఆర్కిటెక్చర్‌లో కూడా ఇలాంటి అద్భుతమైన డీకప్లింగ్‌ను సాధించే సాధనాలే ఇంటర్‌ఫేసెస్ (Interfaces) మరియు అబ్‌స్ట్రాక్ట్ క్లాసెస్ (Abstract Classes). మరియు ఆధునిక క్లౌడ్ / మైక్రోసర్వీసెస్ యుగంలో డేటా ఇమ్యుటబిలిటీ (మార్చలేని సురక్షితమైన డేటా) కోసం C# 9 లో వచ్చిన Records డేటా మోడలింగ్‌ను సమూలంగా మార్చివేశాయి. ఈ అధ్యాయంతో మీరు ఎంటర్‌ప్రైజ్ లెవల్ C# ఆర్కిటెక్చర్ డిజైన్‌లో సంపూర్ణ ప్రావీణ్యం సంపాదిస్తారు!

1 🎭 అబ్‌స్ట్రాక్షన్ (Abstraction) తత్వశాస్త్రం — WHAT vs HOW

అబ్‌స్ట్రాక్షన్ (Abstraction) అంటే అవసరం లేని సంక్లిష్టమైన అంతర్గత సాంకేతిక వివరాలను దాచిపెట్టి (Hiding implementation details), యూజర్‌కు అవసరమైన ప్రధాన ఫీచర్లను మాత్రమే ప్రదర్శించడం (Showing essential features).

  • WHAT (ఏం చేయాలి): ఇంటర్‌ఫేస్ లేదా అబ్‌స్ట్రాక్ట్ క్లాస్ నిర్ణయిస్తుంది (ఉదాహరణ: ProcessPayment(amount)).
  • HOW (ఎలా చేయాలి): కాంక్రీట్ క్లాస్ అమలు చేస్తుంది (ఉదాహరణ: పేపాల్ ద్వారా చేయాలా, క్రెడిట్ కార్డుతో చేయాలా లేదా బిట్‌కాయిన్‌తో చేయాలా).

C# లో అబ్‌స్ట్రాక్షన్‌ను సాధించడానికి రెండు ప్రధాన సాధనాలు ఉన్నాయి: 1. Abstract Classes (పాక్షిక అబ్‌స్ట్రాక్షన్) 2. Interfaces (సంపూర్ణ కాంట్రాక్ట్ అబ్‌స్ట్రాక్షన్).

2 🏛️ అబ్‌స్ట్రాక్ట్ క్లాసెస్ (Abstract Classes) & `abstract` మెథడ్స్

ఒక క్లాస్ ముందు abstract అని రాస్తే, దానికి డైరెక్ట్‌గా ఆబ్జెక్ట్‌ను క్రియేట్ చేయలేము (అంటే new AbstractClass() రాయడం కంపైలేషన్ ఎర్రర్). దానిని కేవలం బేస్ క్లాస్‌గా మాత్రమే ఉపయోగించి, ఇతర పిల్ల క్లాసుల ద్వారా ఇన్‌హెరిట్ చేసుకోవాలి.

అబ్‌స్ట్రాక్ట్ క్లాస్ లక్షణాలు:

  1. Abstract Methods: వీటికి బాడీ { } ఉండదు; కేవలం సిగ్నేచర్ సెమికోలన్ ; తో ముగుస్తుంది. డిరైవ్డ్ క్లాస్ తప్పనిసరిగా override చేయాలి.
  2. Concrete Methods: వీటికి పూర్తి కోడ్ బాడీ ఉంటుంది. అన్ని చైల్డ్ క్లాసులు ఉమ్మడిగా వాడుకోవచ్చు.
  3. Fields & Constructors: ఇవి సాధారణ క్లాసుల లాగే ఫీల్డ్స్‌ను, కన్‌స్ట్రక్టర్లను కలిగి ఉంటాయి. చైల్డ్ కన్‌స్ట్రక్టర్ నుండి base(...) ద్వారా ఇనిషియలైజ్ అవుతాయి.
csharp · Abstract Class with Abstract & Concrete Methods
public abstract class CloudStorageProvider
{
    public string StorageBucketName { get; }

    // కన్‌స్ట్రక్టర్ (చైల్డ్ క్లాసుల కోసం)
    protected CloudStorageProvider(string bucket)
    {
        StorageBucketName = bucket;
    }

    // 1. అబ్‌స్ట్రాక్ట్ మెథడ్ - బాడీ ఉండదు! చైల్డ్ తప్పనిసరిగా కోడ్ రాయాలి
    public abstract void UploadFile(string fileName, byte[] data);

    // 2. కాంక్రీట్ మెథడ్ - అందరికీ కామన్ లాజిక్
    public void PrintBucketInfo()
    {
        Console.WriteLine($"☁️ యాక్టివ్ క్లౌడ్ బకెట్: {StorageBucketName}");
    }
}

// కాంక్రీట్ చైల్డ్ క్లాస్
public class AzureBlobStorage : CloudStorageProvider
{
    public AzureBlobStorage(string bucket) : base(bucket) { }

    public override void UploadFile(string fileName, byte[] data)
    {
        Console.WriteLine($"[Azure] '{fileName}' ({data.Length} బైట్లు) అజూర్ బ్లాబ్‌కు అప్‌లోడ్ అయ్యింది.");
    }
}

// CloudStorageProvider p = new CloudStorageProvider("test"); // ❌ కంపైల్ ఎర్రర్: Cannot create instance of abstract type!
CloudStorageProvider storage = new AzureBlobStorage("prod-media-bucket");
storage.PrintBucketInfo();
storage.UploadFile("invoice.pdf", new byte[1024]);

3 🔌 ఇంటర్‌ఫేసెస్ (Interfaces) అంటే ఏమిటి? ప్యూర్ కాంట్రాక్ట్స్

ఒక ఇంటర్‌ఫేస్ (Interface) అనేది ఒక పవిత్రమైన ఒప్పందం (Formal Contract). "ఈ ఇంటర్‌ఫేస్‌ను ఇంప్లిమెంట్ చేసే ఏ క్లాస్ అయినా సరే, ఖచ్చితంగా ఇందులో పేర్కొన్న మెథడ్స్ మరియు ప్రాపర్టీలను అందించి తీరాలి!".

C# ఇంటర్‌ఫేస్ నియమాలు:

  • పేరు ప్రారంభంలో ప్రామాణికంగా 'I' అక్షరం ఉంటుంది (ఉదా: ILogger, IDisposable, IPaymentGateway).
  • డీఫాల్ట్‌గా అన్ని మెంబర్లు public గా ఉంటాయి.
  • సాంప్రదాయకంగా ఇంటర్‌ఫేస్‌లో ఎటువంటి ఫీల్డ్స్ (ఇన్స్టాన్స్ స్టేట్) లేదా కన్‌స్ట్రక్టర్లు ఉండకూడదు.
  • ఒక క్లాస్ ఎన్ని ఇంటర్‌ఫేస్‌లనైనా ఇంప్లిమెంట్ చేసుకోవచ్చు (Multiple Interface Implementation)!
csharp · Defining & Implementing Interfaces
public interface INotificationService
{
    // ప్రాపర్టీ కాంట్రాక్ట్
    string ProviderName { get; }

    // మెథడ్ కాంట్రాక్ట్స్
    void SendSms(string mobile, string message);
    void SendEmail(string email, string subject, string body);
}

public class TwilioNotificationService : INotificationService
{
    public string ProviderName => "Twilio Enterprise Cloud";

    public void SendSms(string mobile, string message)
    {
        Console.WriteLine($"📱 SMS -> {mobile}: {message} [via {ProviderName}]");
    }

    public void SendEmail(string email, string subject, string body)
    {
        Console.WriteLine($"📧 Email -> {email} | సబ్జెక్ట్: {subject}");
    }
}

INotificationService notifier = new TwilioNotificationService();
notifier.SendSms("+91 9876543210", "మీ OTP: 549102");

4 ⚖️ Abstract Class vs Interface — సమగ్ర పోలిక పట్టిక

సాఫ్ట్‌వేర్ ఆర్కిటెక్ట్ ఇంటర్వ్యూలలో వచ్చే అతి ముఖ్యమైన ప్రశ్న — "ఎప్పుడు అబ్‌స్ట్రాక్ట్ క్లాస్ వాడాలి? ఎప్పుడు ఇంటర్‌ఫేస్ వాడాలి?":

ఫీచర్ Abstract Class Interface
సంబంధం (Relationship) IS-A (గుర్తింపు - ఉదా: Dog IS-A Animal) CAN-DO (సామర్థ్యం - ఉదా: Dog CAN-DO ISwimmable)
బహుళ వారసత్వం వీలుకాదు (ఒక క్లాస్ ఒకే అబ్‌స్ట్రాక్ట్ క్లాస్‌ను ఇన్‌హెరిట్ చేసుకోగలదు) ఖచ్చితంగా సాధ్యం (ఒకే క్లాస్ 10 ఇంటర్‌ఫేస్‌లైనా ఇంప్లిమెంట్ చేయవచ్చు)
ఇన్స్టాన్స్ ఫీల్డ్స్ & స్టేట్ కలిగి ఉండవచ్చు (Fields, Private variables, State) ఇన్స్టాన్స్ ఫీల్డ్స్ అనుమతించబడవు (No state)
కన్‌స్ట్రక్టర్లు కన్‌స్ట్రక్టర్లు ఉండవచ్చు (base(...)) కన్‌స్ట్రక్టర్లు ఉండవు
యాక్సెస్ మోడిఫైయర్లు public, protected, private, internal అన్నీ సాధ్యం సాధారణంగా public
ఉత్తమ వినియోగం ఒకే కుటుంబానికి చెందిన క్లాసుల మధ్య కోడ్ షేరింగ్ కోసం సంబంధం లేని క్లాసుల మధ్య కాంట్రాక్ట్ & DI కోసం

5 🧩 బహుళ ఇంటర్‌ఫేస్ ఇంప్లిమెంటేషన్ & Explicit Interface Implementation

ఒక క్లాస్ బహుళ ఇంటర్‌ఫేస్‌లను కామాలతో వేరు చేసి ఇంప్లిమెంట్ చేయవచ్చు:

public class SmartOrder : IPrintable, ISerializable, IPayable { ... }

ఒకవేళ రెండు ఇంటర్‌ఫేస్‌లలో ఒకే పేరుతో మెథడ్ ఉంటే (ఉదాహరణ: ISaveable.Save() మరియు IDatabase.Save()), నేమింగ్ కొలిజన్‌ను పరిష్కరించడానికి Explicit Interface Implementation వాడతాం:

csharp · Explicit Interface Implementation for Collision Resolution
public interface IFileStorage { void Save(); }
public interface IDatabaseStorage { void Save(); }

public class MultiSaver : IFileStorage, IDatabaseStorage
{
    // Explicit Implementation: ఇంటర్‌ఫేస్ పేరుతో ప్రిఫిక్స్ చేస్తాం, public ఉండకూడదు!
    void IFileStorage.Save()
    {
        Console.WriteLine("💾 స్థానిక డిస్క్‌లోని ఫైల్‌లోకి సేవ్ చేయబడింది.");
    }

    void IDatabaseStorage.Save()
    {
        Console.WriteLine("🗄️ క్లౌడ్ SQL డేటాబేస్‌లోకి సేవ్ చేయబడింది.");
    }
}

MultiSaver saver = new MultiSaver();
// saver.Save(); // ❌ కంపైల్ ఎర్రర్: ఏ Save పిలవాలో తెలియదు!

// ఇంటర్‌ఫేస్ రిఫరెన్స్‌కు కాస్ట్ చేసి పిలవాలి:
IFileStorage fileRef = saver;
fileRef.Save(); // ఫైల్ సేవ్ రన్ అవుతుంది!

IDatabaseStorage dbRef = saver;
dbRef.Save(); // డేటాబేస్ సేవ్ రన్ అవుతుంది!

6 ⚡ C# 8+ Default Interface Methods (ఇంటర్‌ఫేస్‌లో డీఫాల్ట్ కోడ్)

గతంలో ఒక ఇంటర్‌ఫేస్‌కు కొత్త మెథడ్‌ను జోడిస్తే, ఆ ఇంటర్‌ఫేస్‌ను ఇంప్లిమెంట్ చేసే వందలాది పాత క్లాసులు కంపైల్ అవ్వకుండా ఫెయిల్ అయ్యేవి (Breaking Change). దీనికి పరిష్కారంగా C# 8.0 లో Default Interface Methods వచ్చాయి:

csharp · Default Interface Method Example
public interface ILogger
{
    void Log(string message);

    // C# 8+ డీఫాల్ట్ మెథడ్: బాడీ ఉంది! క్లాస్ ఓవర్‌రైడ్ చేయకపోయినా పనిచేస్తుంది
    void LogWarning(string warning)
    {
        Console.WriteLine($"⚠️ [డీఫాల్ట్ హెచ్చరిక]: {warning}");
    }
}

public class ConsoleLogger : ILogger
{
    public void Log(string message) => Console.WriteLine($"INFO: {message}");
    // LogWarning ను ఇక్కడ రాయలేదు, కానీ డీఫాల్ట్ మెథడ్ ఆటోమేటిక్‌గా వస్తుంది!
}

ILogger logger = new ConsoleLogger();
logger.Log("యాప్ రన్ అవుతోంది");
logger.LogWarning("మెమరీ 85% దాటింది!");

7 🔗 డిపెండెన్సీ ఇంజెక్షన్ (DI) & లూజ్ కప్లింగ్ పునాది

ఎంటర్‌ప్రైజ్ ASP.NET Core ఆర్కిటెక్చర్‌లో అత్యంత ముఖ్యమైన సూత్రం: "Program to an interface, not an implementation."

మీ బిజినెస్ క్లాస్ నేరుగా new SqlDatabase() కి బంధించబడి ఉంటే, రేపు MongoDatabase కి మార్చడం లేదా యూనిట్ టెస్ట్ కోసం డమ్మీ మాక్ (Mock) డేటాబేస్ వాడటం అసాధ్యం. కానీ IDatabase ఇంటర్‌ఫేస్‌పై ఆధారపడితే, రన్‌టైమ్‌లో ఏ డేటాబేస్‌నైనా ప్లగ్-అండ్-ప్లే లాగా ఇంజెక్ట్ చేసుకోవచ్చు!

8 💎 C# 9+ విప్లవం: `record` — ఇమ్యుటబుల్ డేటా ఆబ్జెక్ట్స్

ఆధునిక వెబ్ అప్లికేషన్లు, మైక్రోసర్వీసెస్ మరియు క్లౌడ్ API లలో ఎక్కువ భాగం డేటా మార్పిడి (DTOs - Data Transfer Objects) మాత్రమే ఉంటుంది. దీని కోసం సాధారణ క్లాసులు రాస్తే Equals, GetHashCode, ToString, కన్‌స్ట్రక్టర్ల కోసం 50 లైన్ల బాయిలర్‌ప్లేట్ కోడ్ రాయాల్సి వచ్చేది.

ఈ సమస్యను చిటికెలో పరిష్కరించడానికి C# 9 లో వచ్చిన అద్భుతమైన ఫీచరే record (లేదా record class)!

csharp · Positional Record Declaration (One Single Line!)
// కేవలం ఈ ఒక్క లైన్‌తో పూర్తి స్థాయి ఇమ్యుటబుల్ డేటా ఆబ్జెక్ట్ రెడీ!
public record User(int Id, string Name, string Email);

// ఆటోమేటిక్‌గా వచ్చే ఫీచర్లు:
// 1. Primary Constructor
// 2. init-only properties (Id, Name, Email)
// 3. అందమైన ToString() ఫార్మాట్
// 4. Value-based Equality (== మరియు Equals)
// 5. Deconstructor tuple support!

User u = new User(101, "శ్రీధర్ పట్నాయక్", "sridhar@tech.com");
Console.WriteLine(u);
// అవుట్‌పుట్: User { Id = 101, Name = శ్రీధర్ పట్నాయక్, Email = sridhar@tech.com }

9 🔍 Value-based Equality — Class vs Record వ్యత్యాసం

సాధారణ క్లాస్‌లకు, రికార్డులకు మధ్య ఉన్న అతిపెద్ద వ్యత్యాసం ఈక్వాలిటీ (Equality) లో ఉంది:

csharp · Class Equality vs Record Equality
// 1. సాధారణ క్లాస్
public class CustomerClass
{
    public int Id { get; set; }
    public string Name { get; set; }
}

// 2. రికార్డ్
public record CustomerRecord(int Id, string Name);

// క్లాస్ ఆబ్జెక్ట్స్ పోలిక
var c1 = new CustomerClass { Id = 1, Name = "అరుణ్" };
var c2 = new CustomerClass { Id = 1, Name = "అరుణ్" };
Console.WriteLine(c1 == c2); // ❌ FALSE! (ఎందుకంటే వేర్వేరు మెమరీ అడ్రస్‌లు - Reference Equality)

// రికార్డ్స్ పోలిక
var r1 = new CustomerRecord(1, "అరుణ్");
var r2 = new CustomerRecord(1, "అరుణ్");
Console.WriteLine(r1 == r2); // ✅ TRUE! (ఎందుకంటే లోపల విలువలు సమానం - Value Equality)

10 🔄 నాన్-డిస్ట్రక్టివ్ మ్యుటేషన్ — `with` ఎక్స్‌ప్రెషన్

రికార్డ్స్ ఇమ్యుటబుల్ (మార్చలేనివి). మరి ఒక ఫీల్డ్ మార్చాలంటే మొత్తం కొత్త ఆబ్జెక్ట్ మొదటి నుండి రాయాలా? అవసరం లేదు! C# with ఎక్స్‌ప్రెషన్ ద్వారా అసలు ఆబ్జెక్ట్‌ను డిస్టర్బ్ చేయకుండా, కేవలం కావాల్సిన ఫీల్డ్‌ను మాత్రమే మార్చి ఒక కొత్త క్లోన్ (Clone) కాపీని తక్షణమే తయారు చేయవచ్చు:

csharp · Non-Destructive Mutation with 'with'
public record ProductOrder(string OrderId, string Sku, int Quantity, decimal TotalPrice);

ProductOrder originalOrder = new ProductOrder("ORD-101", "IPHONE-15", 1, 79900m);

// Quantity మరియు TotalPrice ని మాత్రమే మార్చి సరికొత్త ఆర్డర్ కాపీని క్రియేట్ చేయడం
ProductOrder updatedOrder = originalOrder with 
{ 
    Quantity = 2, 
    TotalPrice = 159800m 
};

Console.WriteLine($"అసలు ఆర్డర్: {originalOrder}");
Console.WriteLine($"కొత్త ఆర్డర్: {updatedOrder}");
// అసలు ఆర్డర్ ఏమాత్రం చెడిపోలేదు (100% Immutable Safety)!

11 🚀 `record struct` (C# 10+) — జీరో హీప్ అలోకేషన్

C# 10 లో రికార్డ్స్ స్ట్రక్ట్స్‌కు కూడా అందుబాటులోకి వచ్చాయి:

  • record class (లేదా కేవలం record): Reference Type, Heap లో స్టోర్ అవుతుంది.
  • record struct: Value Type, Stack లో స్టోర్ అవుతుంది. Garbage Collector కి ఎలాంటి పనీ ఉండదు!

హై-ఫ్రీక్వెన్సీ ట్రేడింగ్, గేమ్ ఇంజిన్స్, గ్రాఫిక్స్ కోఆర్డినేట్స్ (record struct Point(int X, int Y);) లాంటి ప్రదేశాల్లో ఇది అద్భుతమైన వేగాన్ని అందిస్తుంది.

12 🛒 రియల్-వరల్డ్ ప్రాజెక్ట్ — ఎంటర్‌ప్రైజ్ ఈ-కామర్స్ ఆర్డర్ ప్రాసెసింగ్ ఇంజిన్

ఈ అధ్యాయంలో నేర్చుకున్న Interfaces, Abstract Classes, Records, with expression, మరియు Polymorphic Discount Strategies అన్నింటినీ ఏకీకృతం చేసి ఒక పూర్తి స్థాయి ఈ-కామర్స్ ఆర్డర్ పైప్‌లైన్ ఇంజిన్ (E-Commerce Pipeline Engine v1.0) నిర్మిద్దాం.

csharp · Enterprise E-Commerce Order & Discount Pipeline
using System;
using System.Collections.Generic;

Console.OutputEncoding = System.Text.Encoding.UTF8;

Console.WriteLine("=================================================");
Console.WriteLine("🛍️ మన షాప్ - ఎంటర్‌ప్రైజ్ ఆర్డర్ & డిస్కౌంట్ ఇంజిన్ v1.0");
Console.WriteLine("=================================================\n");

// 1. Immutable Records (DTOs)
public record CustomerInfo(string CustomerId, string Name, string Email, string Tier);
public record CartItem(string Sku, string Title, decimal Price, int Quantity);
public record OrderResult(string OrderId, decimal GrossTotal, decimal Discount, decimal NetPayable, string Status);

// 2. Interfaces (Contracts)
public interface IPaymentGateway
{
    string GatewayName { get; }
    bool Charge(string customerId, decimal amount, out string transactionRef);
}

public interface INotifier
{
    void SendConfirmation(CustomerInfo customer, OrderResult order);
}

// 3. Abstract Class: Discount Strategy
public abstract class DiscountStrategy
{
    public string StrategyName { get; }
    protected DiscountStrategy(string name) => StrategyName = name;

    public abstract decimal CalculateDiscount(CustomerInfo customer, decimal grossTotal);
}

// కాంక్రీట్ డిస్కౌంట్ క్లాసులు
public class FestiveDiscount : DiscountStrategy
{
    public FestiveDiscount() : base("సంక్రాంతి ఫెస్టివల్ సేల్ (10% రాయితీ)") { }

    public override decimal CalculateDiscount(CustomerInfo customer, decimal grossTotal)
    {
        return grossTotal >= 5000m ? grossTotal * 0.10m : 0m;
    }
}

public class VipTierDiscount : DiscountStrategy
{
    public VipTierDiscount() : base("VIP ప్రివిలేజ్ డిస్కౌంట్ (20% రాయితీ)") { }

    public override decimal CalculateDiscount(CustomerInfo customer, decimal grossTotal)
    {
        return customer.Tier == "VIP" ? grossTotal * 0.20m : 0m;
    }
}

// 4. కాంక్రీట్ సర్వీసెస్ (ఇంటర్‌ఫేస్ ఇంప్లిమెంటేషన్స్)
public class RazorpayGateway : IPaymentGateway
{
    public string GatewayName => "Razorpay Secure Payments";

    public bool Charge(string customerId, decimal amount, out string transactionRef)
    {
        transactionRef = "RZP-" + Guid.NewGuid().ToString().Substring(0, 8).ToUpper();
        Console.WriteLine($"💳 [{GatewayName}] కస్టమర్ {customerId} నుండి ₹{amount:N2} సక్సెస్‌ఫుల్‌గా ఛార్జ్ చేయబడింది.");
        return true;
    }
}

public class EmailNotifier : INotifier
{
    public void SendConfirmation(CustomerInfo customer, OrderResult order)
    {
        Console.WriteLine($"\n📩 [Email నోటిఫికేషన్] -> {customer.Email}");
        Console.WriteLine($"   ప్రియమైన {customer.Name}, మీ ఆర్డర్ {order.OrderId} విజయవంతంగా పూర్తయింది!");
        Console.WriteLine($"   మొత్తం చెల్లింపు: ₹{order.NetPayable:N2} (రాయితీ: ₹{order.Discount:N2})\n");
    }
}

// 5. మెయిన్ ఆర్డర్ ప్రాసెసర్ (డిపెండెన్సీ ఇంజెక్షన్ పునాది)
public class OrderProcessor(IPaymentGateway paymentGateway, INotifier notifier)
{
    public OrderResult ProcessCheckout(CustomerInfo customer, List cart, DiscountStrategy discountPolicy)
    {
        Console.WriteLine($"🛒 ఆర్డర్ చెక్అవుట్ ప్రారంభమైంది: {customer.Name} ({customer.Tier})");

        decimal grossTotal = 0m;
        foreach (var item in cart) grossTotal += item.Price * item.Quantity;

        decimal discount = discountPolicy.CalculateDiscount(customer, grossTotal);
        decimal netPayable = grossTotal - discount;

        Console.WriteLine($"   స్థూల మొత్తం  : ₹{grossTotal:N2}");
        Console.WriteLine($"   వర్తించిన రాయితీ: ₹{discount:N2} [{discountPolicy.StrategyName}]");
        Console.WriteLine($"   నికర చెల్లింపు: ₹{netPayable:N2}");

        if (paymentGateway.Charge(customer.CustomerId, netPayable, out string txRef))
        {
            var result = new OrderResult("ORD-" + Guid.NewGuid().ToString().Substring(0, 6).ToUpper(),
                                         grossTotal, discount, netPayable, "CONFIRMED");

            notifier.SendConfirmation(customer, result);
            return result;
        }

        return new OrderResult("FAILED", grossTotal, 0, 0, "PAYMENT_FAILED");
    }
}

// డ్రైవర్ కోడ్: ఎగ్జిక్యూషన్
var customer1 = new CustomerInfo("CUST-901", "శ్రీవాత్సవ వర్మ", "vatsava@email.com", "VIP");
var cartItems = new List
{
    new CartItem("SKU-LAP", "డెల్ ఆల్ట్రాబుక్", 65000m, 1),
    new CartItem("SKU-MOU", "వైర్‌లెస్ మౌస్", 1500m, 2)
};

var processor = new OrderProcessor(new RazorpayGateway(), new EmailNotifier());

// VIP డిస్కౌంట్‌తో ప్రాసెస్ చేయడం
processor.ProcessCheckout(customer1, cartItems, new VipTierDiscount());

// నాన్-డిస్ట్రక్టివ్ మ్యుటేషన్ 'with' టెస్ట్
var customer2 = customer1 with { CustomerId = "CUST-902", Name = "హరీష్ నాయుడు", Tier = "Regular", Email = "harish@email.com" };
processor.ProcessCheckout(customer2, cartItems, new FestiveDiscount());

Console.WriteLine("=================================================");

💻 ఈ ఈ-కామర్స్ ఆర్డర్ ఇంజిన్‌ను లైవ్ కంపైలర్‌లో రన్ చేసి చూడండి!

Records, Interfaces, Abstract Discount Strategy, మరియు 'with' మ్యుటేషన్లను ప్రత్యక్షంగా పరిశీలించండి.

13 🎓 ఇంటర్వ్యూ ప్రశ్నలు, బెస్ట్ ప్రాక్టీసెస్ & 5 ఇంటరాక్టివ్ క్విజ్ ప్రశ్నలు

టాప్ ఇంటర్వ్యూ ప్రశ్నలు & సమాధానాలు:

Q1: C# లో record కి సాధారణ class కి మధ్య ప్రధాన వ్యత్యాసాలు ఏమిటి?

జవాబు: 1) Records డీఫాల్ట్‌గా Value-based Equality ని అందిస్తాయి (లోపల ఫీల్డ్స్ సమానమైతే == ట్రూ అవుతుంది), క్లాసెస్ Reference Equality ని వాడతాయి. 2) Records ఇమ్యుటబుల్ డేటా మోడలింగ్‌కు ప్రాధాన్యత ఇస్తూ with ఎక్స్‌ప్రెషన్‌ను సపోర్ట్ చేస్తాయి. 3) Records ఆటోమేటిక్‌గా అందమైన ToString() మరియు Deconstructors ని అందిస్తాయి.

Q2: Explicit Interface Implementation ఎప్పుడు వాడతారు?

జవాబు: ఒక క్లాస్ రెండు వేర్వేరు ఇంటర్‌ఫేస్‌లను ఇంప్లిమెంట్ చేస్తున్నప్పుడు, రెండింటిలోనూ ఒకే పేరు, ఒకే పారామీటర్లు ఉన్న మెథడ్ ఉంటే నేమింగ్ కొలిజన్ నివారించడానికి void IInterfaceA.Method() రూపంలో ఎక్స్‌ప్లిసిట్ ఇంప్లిమెంటేషన్ వాడతారు.

🧠 మీ నాలెడ్జ్ చెక్ చేసుకోండి — 5 ఇంటరాక్టివ్ క్విజ్ ప్రశ్నలు

❓ ప్రశ్న 1: అబ్‌స్ట్రాక్ట్ క్లాస్‌కు new AbstractClass() ద్వారా ఆబ్జెక్ట్‌ను సృష్టించవచ్చా?
సమాధానం: లేదు. అబ్‌స్ట్రాక్ట్ క్లాసెస్ అసంపూర్ణమైన బ్లూప్రింట్లు. వాటికి నేరుగా ఆబ్జెక్ట్ సృష్టించడం కంపైల్-టైమ్ ఎర్రర్. వాటిని చైల్డ్ క్లాస్ ద్వారా మాత్రమే ఇన్‌హెరిట్ చేసుకోవాలి.
❓ ప్రశ్న 2: ఒక C# క్లాస్ గరిష్టంగా ఎన్ని ఇంటర్‌ఫేస్‌లను ఇంప్లిమెంట్ చేసుకోవచ్చు?
సమాధానం: పరిమితి లేదు (బహుళ ఇంటర్‌ఫేస్‌లు). ఒక క్లాస్ ఒకే ఒక్క క్లాస్ నుండి మాత్రమే ఇన్‌హెరిట్ చేసుకోగలదు, కానీ ఎన్ని ఇంటర్‌ఫేస్‌లనైనా ఇంప్లిమెంట్ చేయవచ్చు.
❓ ప్రశ్న 3: C# 8 లో ఇంటర్‌ఫేస్‌లకు వచ్చిన సరికొత్త ఫీచర్ ఏమిటి?
సమాధానం: Default Interface Methods. ఇంటర్‌ఫేస్ లోపల కూడా డీఫాల్ట్ కోడ్ బాడీని అందించవచ్చు, దీనివల్ల పాత క్లాసులను బ్రేక్ చేయకుండా కొత్త మెథడ్స్ జోడించవచ్చు.
❓ ప్రశ్న 4: ఒక రికార్డ్ యొక్క కాపీని తీసుకొని అందులో కొన్ని ఫీల్డ్స్‌ను మాత్రమే సవరించడానికి ఏ ఎక్స్‌ప్రెషన్ వాడాలి?
సమాధానం: with ఎక్స్‌ప్రెషన్ (Non-destructive mutation). ఉదాహరణ: var newRec = oldRec with { Salary = 50000 };.
❓ ప్రశ్న 5: record struct మరియు record class మధ్య మెమరీ వ్యత్యాసం ఏమిటి?
సమాధానం: record class అనేది Reference Type (Heap మెమరీలో స్టోర్ అవుతుంది, GC కలెక్ట్ చేస్తుంది). record struct అనేది Value Type (Stack లో స్టోర్ అవుతుంది, జీరో GC అలోకేషన్).
← Previous: 15. ఇన్‌హెరిటెన్స్ & పాలిమార్ఫిజం Next: 17. ఎక్సెప్షన్ హ్యాండ్లింగ్ (Phase 05) →
OC
Written by Our Compiler Technical Editorial Team
Reviewed for accuracy & tested on .NET 8 SDK / C# 12 runtime · 2026 Academic Edition