फंक्शनल बनाम OOP in C#: 2025 में क्या चुनें?

परिचय: एक ही सिक्के के दो पहलू

कल्पना करें कि आप एक घर बना रहे हैं। आप तैयार ब्लॉक (क्लासेस, ऑब्जेक्ट्स, इनहेरिटेंस) ले सकते हैं और उनसे एक जटिल संरचना बना सकते हैं — यह ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग (OOP) है। या आप एक गणितज्ञ की तरह सोच सकते हैं: "मैं डेटा लेता हूँ, उस पर एक शुद्ध फंक्शन लागू करता हूँ और बिना कुछ बदले एक नया परिणाम प्राप्त करता हूँ" — यह फंक्शनल प्रोग्रामिंग है।

C# में दोनों प्रतिमान अद्भुत रूप से एक साथ रहते हैं। और यदि आप इस भाषा में लिखते हैं, तो देर-सबेर आप खुद से पूछेंगे: "क्या होगा अगर मैं यह गलत कर रहा हूँ? शायद मुझे LINQ का अधिक उपयोग करना चाहिए और क्लासेस का कम?"

इस लेख में हम यह बहस नहीं करेंगे कि क्या बेहतर है। हम समझेंगे कि C# में फंक्शनल दृष्टिकोण OOP से कैसे अलग है, प्रत्येक वास्तव में कब मदद करता है, और कब नुकसान पहुँचाता है। और हाँ, बहुत सारा कोड होगा। चलिए शुरू करते हैं!

1. C# में OOP: क्लासिक जो काम करता है

ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग स्थिति और व्यवहार के बारे में है। आपके पास एक क्लास है जो डेटा (फील्ड्स, प्रॉपर्टीज) और विधियाँ संग्रहीत करता है जो इस डेटा को बदलते हैं।

उदाहरण: ऑनलाइन स्टोर में ऑर्डर प्रबंधन के लिए एप्लिकेशन।

public class Order\n{\n    public int Id { get; set; }\n    public List<string> Items { get; private set; }\n    public decimal TotalPrice { get; private set; }\n\n    public Order(int id)\n    {\n        Id = id;\n        Items = new List<string>();\n        TotalPrice = 0;\n    }\n\n    public void AddItem(string itemName, decimal price)\n    {\n        Items.Add(itemName);\n        TotalPrice += price;\n    }\n\n    public void ApplyDiscount(decimal percent)\n    {\n        TotalPrice -= TotalPrice * (percent / 100);\n    }\n}

हम क्या देखते हैं? एनकैप्सुलेशन: TotalPrice को सीधे नहीं बदला जा सकता — केवल विधियों के माध्यम से। स्थिति समय के साथ बदलती है: हम आइटम जोड़ते हैं, छूट लागू करते हैं। यह शुद्ध OOP है।

C# में OOP के लाभ

\n
• वास्तविक दुनिया का स्पष्ट मॉडल: ऑर्डर, ग्राहक, उत्पाद — सब कुछ जीवन की तरह।
\n
• पुन: उपयोग इनहेरिटेंस और इंटरफेस के माध्यम से।
\n
• जटिलता प्रबंधन छोटे ऑब्जेक्ट्स में विभाजन के कारण।
\n

OOP के नुकसान

\n
• साइड इफेक्ट्स: एक विधि स्थिति बदल सकती है, और आप आसानी से नियंत्रण खो सकते हैं।
\n
• परीक्षण की जटिलता: ऑब्जेक्ट्स बनाने, डिपेंडेंसी मॉक करने की आवश्यकता होती है।
\n
• अतिरेकता: कभी-कभी पूरी क्लास बनाने की तुलना में एक फंक्शन लिखना आसान होता है।
\n

2. C# में फंक्शनल दृष्टिकोण: LINQ और उससे आगे

फंक्शनल प्रोग्रामिंग शुद्ध फंक्शन्स (बिना साइड इफेक्ट्स के) और डेटा की अपरिवर्तनीयता के बारे में है। C# में यह विशेष रूप से LINQ, लैम्ब्डा एक्सप्रेशन और कलेक्शन के साथ काम करने में दिखाई देता है।

आइए उसी कार्य को हल करें — ऑर्डर प्रबंधन — लेकिन फंक्शनल तरीके से।

// अपरिवर्तनीय रिकॉर्ड\npublic record Order(int Id, List<string> Items, decimal TotalPrice);\n\npublic static class OrderFunctions\n{\n    public static Order AddItem(Order order, string item, decimal price)\n    {\n        var newItems = order.Items.Append(item).ToList();\n        return order with { Items = newItems, TotalPrice = order.TotalPrice + price };\n    }\n\n    public static Order ApplyDiscount(Order order, decimal percent)\n    {\n        return order with { TotalPrice = order.TotalPrice * (1 - percent / 100) };\n    }\n}\n\n// उपयोग\nvar order = new Order(1, new List<string>(), 0);\norder = OrderFunctions.AddItem(order, "लैपटॉप", 50000);\norder = OrderFunctions.ApplyDiscount(order, 10);

ध्यान दिया? हम मूल ऑब्जेक्ट को नहीं बदलते। हर बार with का उपयोग करके एक नया इंस्टेंस बनाया जाता है। यह आकस्मिक परिवर्तनों को समाप्त करता है।

और