HI
RU
EN
ES
ZH
FR
DE
PT
AR
C# में मेटाप्रोग्रामिंग: जब कोड कोड लिखता है
\n\nकल्पना करें कि आप एक आर्किटेक्ट हैं जो सिर्फ एक घर नहीं बना रहा है, बल्कि एक रोबोट-बिल्डर बना रहा है जो खुद दीवारें खड़ी करता है, वायरिंग बिछाता है और फ़ेसेड पेंट करता है। C# की दुनिया में, यह "रोबोट" मेटाप्रोग्रामिंग है — प्रोग्राम लिखने की कला जो निष्पादन के दौरान अन्य प्रोग्राम (या स्वयं) बनाते, विश्लेषण करते या संशोधित करते हैं।
\n\nइसकी आवश्यकता क्यों है? कल्पना करें कि आप JSON के साथ काम करने के लिए दर्जनों समान क्लास लिख रहे हैं, जटिल प्लगइन सिस्टम बना रहे हैं, या रिफ्लेक्शन के माध्यम से सैकड़ों मेथड को मैन्युअल रूप से कॉल करने में आलस कर रहे हैं। C# में मेटाप्रोग्रामिंग आपको दिनचर्या को स्वचालित करने, लचीले फ्रेमवर्क बनाने और विकास को कई गुना तेज करने की अनुमति देता है। आज हम इस तकनीक के तीन स्तंभों पर चर्चा करेंगे: रिफ्लेक्शन, एक्सप्रेशन ट्री और डायनामिक कोड जनरेशन।
\n\nयह लेख उन लोगों के लिए है जो पहले से ही C# में आत्मविश्वास से लिखते हैं, लेकिन CLR के अंदर झांकना चाहते हैं और वह जादू सीखना चाहते हैं जो एक सीनियर को मिडल से अलग करता है। चलिए शुरू करते हैं!
\n\nरिफ्लेक्शन (Reflection): आपके कोड के लिए एक्स-रे
\n\nरिफ्लेक्शन C# में मेटाप्रोग्रामिंग की नींव है। यह निष्पादन के दौरान टाइप, मेथड, प्रॉपर्टी और फील्ड के बारे में जानकारी प्राप्त करने के साथ-साथ उन्हें डायनामिक रूप से कॉल करने की अनुमति देता है। कल्पना करें कि आप किसी ऑब्जेक्ट को एक खुली किताब की तरह देख रहे हैं और उसका कोई भी पेज पढ़ सकते हैं।
\n\nटाइप के बारे में जानकारी प्राप्त करना
\n\nसबसे आसान तरीका है कीवर्ड typeof या मेथड GetType() का उपयोग करना:
Type stringType = typeof(string);\nConsole.WriteLine($"नाम: {stringType.Name}"); // String\nConsole.WriteLine($"नेमस्पेस: {stringType.Namespace}"); // System\nConsole.WriteLine($"क्या यह क्लास है? {stringType.IsClass}"); // Trueमेथड का डायनामिक कॉल
\n\nमान लीजिए कि आपके पास एक क्लास Calculator है, और आप इसकी मेथड Add को कॉल करना चाहते हैं, जिसका नाम केवल रनटाइम पर ज्ञात होता है (उदाहरण के लिए, कॉन्फ़िगरेशन से):
public class Calculator\n{\n public int Add(int a, int b) => a + b;\n}\n\n// रिफ्लेक्शन का उपयोग करें\nCalculator calc = new Calculator();\nType calcType = typeof(Calculator);\nMethodInfo? addMethod = calcType.GetMethod("Add");\n\nif (addMethod != null)\n{\n int result = (int)addMethod.Invoke(calc, new object[] { 5, 3 });\n Console.WriteLine($"परिणाम: {result}"); // 8\n}रिफ्लेक्शन कब उपयोगी है?
\n- \n
- सीरियलाइज़ेशन / डीसीरियलाइज़ेशन — Newtonsoft.Json जैसी लाइब्रेरीज़ सक्रिय रूप से रिफ्लेक्शन का उपयोग करती हैं। \n
- प्लगइन — बाहरी असेंबली लोड करना और उनकी मेथड कॉल करना। \n
- टेस्टिंग — प्राइवेट फील्ड और मेथड तक पहुंच (हालांकि ऐसा न करना बेहतर है)। \n
महत्वपूर्ण! रिफ्लेक्शन एक धीमी प्रक्रिया है। यदि आप एक ही मेथड को हजारों बार कॉल कर रहे हैं, तो MethodInfo को कैश करने या डेलिगेट का उपयोग करने पर विचार करें।
एक्सप्रेशन ट्री (Expression Trees): कोड डेटा के रूप में
\n\nएक्सप्रेशन ट्री कोड को डेटा संरचना (ट्री) के रूप में प्रस्तुत करने का एक तरीका है। आप इस कोड का विश्लेषण, संशोधन और यहां तक कि "मौके पर" संकलन कर सकते हैं। यह ORM (Entity Framework), वैलिडेटर और डायनामिक क्वेरी बनाने के लिए एक शक्तिशाली उपकरण है।
\n\nएक सरल ट्री बनाना
\n\nलैम्ब्डा x => x * 2 लिखने के बजाय, हम इसे मैन्युअल रूप से बनाते हैं:
using System.Linq.Expressions;\n\n// पैरामीटर x बनाएँ\nParameterExpression param = Expression.Parameter(typeof(int), "x");\n// कॉन्स्टेंट 2 बनाएँ\nConstantExpression constant = Expression.Constant(2);\n// गुणा x * 2 बनाएँ\nBinaryExpression body = Expression.Multiply(param, constant);\n// सब कुछ लैम्ब्डा में इकट्ठा करें: x => x * 2\nExpression<Func<int, int>> lambda = Expression.Lambda<Func<int, int>>(body, param);\n\n// संकलित करें और निष्पादित करें\nFunc<int, int> compiled 
