C# पर लीगेसी कोड का रिफैक्टरिंग: चरण-दर-चरण मार्गदर्शिका

परिचय: C# में लीगेसी कोड का रिफैक्टरिंग क्यों आवश्यक है

प्रत्येक .NET डेवलपर को देर-सबेर लीगेसी कोड का सामना करना पड़ता है। यह जरूरी नहीं कि .NET Framework 1.1 पर 20 साल पुराना प्रोजेक्ट हो — अक्सर एक साल पहले जल्दबाजी में, बिना टेस्ट के और SOLID सिद्धांतों का उल्लंघन करते हुए लिखा गया कोड भी "लीगेसी" बन जाता है। ऐसे कोड के साथ काम करना एक बुरा सपना बन जाता है: कोई भी बदलाव अप्रत्याशित स्थानों पर कार्यक्षमता को तोड़ देता है, और तर्क को केवल डीबग के माध्यम से ही समझा जा सकता है।

रिफैक्टरिंग का मतलब शुरू से दोबारा लिखना नहीं है। यह बाहरी व्यवहार को बदले बिना कोड की आंतरिक संरचना में सुधार करना है। इस लेख में, हम C# में लीगेसी कोड के रिफैक्टरिंग की व्यावहारिक तकनीकों पर चर्चा करेंगे, जिन्हें आप जोखिम को कम करते हुए तुरंत लागू कर सकते हैं।

1. तैयारी: रिफैक्टरिंग का सुनहरा नियम

कोड बदलने से पहले, सुनिश्चित करें कि आपके पास एक "सुरक्षा जाल" है — स्वचालित टेस्ट का एक सेट। इनके बिना, रिफैक्टरिंग अनुमान लगाने जैसा हो जाता है।

कैरेक्टराइजेशन टेस्ट बनाना

यदि टेस्ट नहीं हैं, तो कैरेक्टराइजेशन टेस्ट (जिन्हें गोल्डन मास्टर या स्नैपशॉट टेस्ट भी कहा जाता है) लिखें। विचार सरल है: विभिन्न इनपुट डेटा के साथ मेथड को चलाएं, परिणाम रिकॉर्ड करें, और फिर जांचें कि रिफैक्टरिंग के बाद परिणाम नहीं बदला है।

// लीगेसी मेथड के लिए कैरेक्टराइजेशन टेस्ट का उदाहरण[Test]public void CalculateTotal_ShouldReturnSameResult_AfterRefactoring(){    // Arrange    var order = new Order { Items = new List<Item> { new Item { Price = 100, Quantity = 2 } } };    var expected = 200; // पहले से ज्ञात परिणाम

    // Act    var result = LegacyOrderCalculator.CalculateTotal(order);

    // Assert    Assert.AreEqual(expected, result);}

सुझाव: स्वचालित स्नैपशॉट-टेस्टिंग के लिए Verify या ApprovalTests जैसी लाइब्रेरी का उपयोग करें।

2. तकनीक #1: मेथड निकालना (Extract Method)

सबसे सरल और प्रभावी तकनीक। जब आप 200 लाइनों का कोई मेथड देखते हैं जिसमें "// यहां डिस्काउंट की गणना" जैसी टिप्पणियाँ हों — यह एक आदर्श उम्मीदवार है।

उदाहरण: बड़ा मेथड

public decimal ProcessOrder(Order order){    decimal total = 0;    foreach (var item in order.Items)    {        total += item.Price * item.Quantity;    }

    // डिस्काउंट की गणना    if (order.Customer.IsPremium)    {        total *= 0.9m; // 10% डिस्काउंट    }    else if (order.TotalAmount > 1000)    {        total *= 0.95m; // 5% डिस्काउंट    }

    // टैक्स लागू करना    total *= 1.2m; // 20% टैक्स

    return total;}

रिफैक्टरिंग के बाद

public decimal ProcessOrder(Order order){    decimal subtotal = CalculateSubtotal(order.Items);    decimal afterDiscount = ApplyDiscount(subtotal, order.Customer);    return ApplyTax(afterDiscount);}

private decimal CalculateSubtotal(IEnumerable<Item> items){    return items.Sum(item => item.Price * item.Quantity);}

private decimal ApplyDiscount(decimal total, Customer customer){    if (customer.IsPremium)        return total * 0.9m;    if (total > 1000)        return total * 0.95m;    return total;}

private decimal ApplyTax(decimal amount){    return amount * 1.2m;}

लाभ:

• प्रत्येक मेथड की एक ही जिम्मेदारी है
• कोड पढ़ने योग्य और टेस्ट करने योग्य हो जाता है
• डिस्काउंट लॉजिक को अन्य स्थानों पर पुनः उपयोग किया जा सकता है

3. तकनीक #2: सशर्त तर्क को पॉलीमॉर्फिज्म से बदलना

लीगेसी कोड में अक्सर if-else या switch की लंबी श्रृंखलाएँ होती हैं। यह ओपन/क्लोज्ड सिद्धांत (OCP) का उल्लंघन करता है।

उदाहरण: दस्तावेज़ प्रकार के अनुसार Switch

public decimal CalculateShippingCost(Order order){    switch (order.ShippingType)    {        case "Standard":            return 5;        case "Express":            return 15;        case "Overnight
```