Mono.Cecil का उपयोग करके MSIL कोड को तीसरे पक्ष की विधानसभा में इंजेक्ट करना। नेट में एओपी सिद्धांतों को लागू करना

परिचय

इस लेख में, मैं इस बारे में बात करूंगा कि आप अपने कोड को मौजूदा .NET असेंबली में कैसे जोड़ सकते हैं और यह कैसे पहलू-उन्मुख प्रोग्रामिंग से संबंधित है। लेख काम करने के उदाहरणों के साथ होगा, क्योंकि मेरा मानना ​​है कि कोड एक विचार व्यक्त करने का सबसे अच्छा तरीका है।



कई .NET डेवलपर्स जानते हैं कि आप किसी अन्य असेंबली की वस्तुओं तक पहुंचने के लिए रिफ्लेक्शन का उपयोग कर सकते हैं। System.Reflection से प्रकारों का उपयोग करके, हम असेंबली में कई .NET ऑब्जेक्ट्स को एक्सेस कर सकते हैं, उनके मेटाडेटा को देख सकते हैं, और यहां तक ​​कि उन ऑब्जेक्ट्स का भी उपयोग कर सकते हैं जो एक्सेस करने के लिए प्रतिबंधित हैं (उदाहरण के लिए, किसी अन्य क्लास के निजी तरीके)। लेकिन परावर्तन के उपयोग की अपनी सीमाएँ हैं और इसका मुख्य कारण यह है कि जिस डेटा पर आप परावर्तन के माध्यम से काम करते हैं उसे अभी भी कोड माना जाता है। इस प्रकार, उदाहरण के लिए, यदि आप जिस विधानसभा में रिफ्लेक्शन लागू करने का प्रयास कर रहे हैं, उसके लिए आपको कोडअशेसिसिटी अपवाद मिल सकता है। उसी कारण से, परावर्तन बहुत धीमा है। लेकिन इस लेख के लिए सबसे महत्वपूर्ण बात यह है कि मानक परावर्तन आपको मौजूदा विधानसभाओं को संशोधित करने की अनुमति नहीं देता है, केवल नए लोगों को उत्पन्न करता है और बचाता है।

Mono.Cecil

एक पूरी तरह से अलग दृष्टिकोण मुफ्त खुला स्रोत पुस्तकालय Mono.Cecil द्वारा की पेशकश की है। Mono.Cecil दृष्टिकोण और प्रतिबिंब दृष्टिकोण के बीच मुख्य अंतर यह है कि यह पुस्तकालय बाइट की एक धारा के रूप में NET असेंबली के साथ काम करता है। असेंबली को लोड करते समय, Mono.Cecil पीई हेडर, सीएलआर हेडर, वर्गों और विधियों के लिए एमएसआईएल कोड, आदि को पार्स करता है। विधानसभा का प्रतिनिधित्व करने वाली बाइट स्ट्रीम के साथ सीधे काम करना। इस प्रकार, इस लाइब्रेरी की मदद से, आप अपनी इच्छानुसार मौजूदा असेंबली को संशोधित कर सकते हैं (सीमा के भीतर)।



आप यहां Mono.Cecil डाउनलोड कर सकते हैं ।



तुरंत, मैं ध्यान देता हूं कि एक मजबूत नाम के साथ हस्ताक्षर किए गए तृतीय-पक्ष विधानसभा के एक संशोधन से सभी आगामी परिणामों के साथ हस्ताक्षर का एक रीसेट हो जाएगा। संशोधन के बाद, विधानसभा को फिर से हस्ताक्षरित किया जा सकता है (उसी कुंजी के साथ, यदि आपके पास एक है, या दूसरे के साथ - यदि, उदाहरण के लिए, आपको विधानसभा को जीएसी में रखने की आवश्यकता है)।

एक छोटा सा उदाहरण

केवल Mono.Cecil की क्षमताओं का उपयोग करके एक उदाहरण देखें। मान लीजिए कि हमारे पास स्रोत कोड के बिना कुछ कंसोल एप्लिकेशन का एक तृतीय-पक्ष असेंबली है, जिसमें एक प्रकार का प्रोग्राम है। हमारे पास स्रोत कोड तक पहुंच नहीं है, लेकिन हम चाहते हैं कि यह एप्लिकेशन कंसोल के लिए एक संदेश को आउटपुट करे जब प्रत्येक विधि कहा जाता है। ऐसा करने के लिए, हम अपने स्वयं के कंसोल एप्लिकेशन को लिखेंगे। स्टार्टअप पर एक तर्क के रूप में, हम लक्ष्य आवेदन के लिए रास्ता पास करेंगे:

using Mono.Cecil; using Mono.Cecil.Cil; class Program { static void Main(string[] args) { if (args.Length == 0) return; string assemblyPath = args[0]; //     Mono.Cecil var assembly = AssemblyDefinition.ReadAssembly(assemblyPath); //   Console.WriteLine,    Reflection var writeLineMethod = typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }); //    ,  Reflection,    Mono.Cecil var writeLineRef = assembly.MainModule.Import(writeLineMethod); foreach (var typeDef in assembly.MainModule.Types) { foreach (var method in typeDef.Methods) { //       //     "Inject!" method.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Ldstr, "Inject!")); //   Console.WriteLine,      -     "Injected". method.Body.Instructions.Insert(1, Instruction.Create(OpCodes.Call, writeLineRef)); } } assembly.Write(assemblyPath); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

किसी तीसरे पक्ष की असेंबली के लिए पथ को हमारे कंसोल एप्लिकेशन में स्थानांतरित करते समय, यह कोड "Inject!" जोड़ेगा, प्रत्येक IL पद्धति की शुरुआत में कंसोल पर, और फिर संशोधित असेंबली को सहेजें। जब आप एक संशोधित असेंबली शुरू करते हैं, तो प्रत्येक विधि "इंजेक्ट!" कंसोल पर लिख देगी।



हमें उपरोक्त कोड पर ध्यान दें। जैसा कि आप जानते हैं, NET कई प्रोग्रामिंग भाषाओं का समर्थन करता है। यह इस तथ्य के कारण हासिल किया गया है कि किसी भी प्रोग्रामिंग भाषा में कोई भी कोड CIL - सामान्य मध्यवर्ती भाषा - एक मध्यवर्ती भाषा में संकलित है। क्यों बीच में? क्योंकि उसके बाद, CIL कोड को संबंधित प्रोसेसर के निर्देशों में बदल दिया जाता है। इस प्रकार, किसी भी भाषा में कोड को लगभग उसी CIL कोड में संकलित किया जाता है, जिसके कारण आप उपयोग कर सकते हैं, उदाहरण के लिए, आपके C # प्रोजेक्ट में VB पर असेंबली।



इस प्रकार, प्रत्येक विधानसभा अपेक्षाकृत मेटाडेटा का एक सेट बोल रही है (जो, उदाहरण के लिए, प्रतिबिंब का उपयोग करता है), और सीआईएल में निर्देशों का एक सेट।



मैं CIL के विवरण पर ध्यान नहीं दूंगा, क्योंकि यह इस लेख का विषय नहीं है। मैं खुद को सीमित करूंगा कि भविष्य के लिए क्या महत्वपूर्ण होगा, अर्थात्, CIL निर्देशों की कुछ विशेषताओं के लिए। आप हमेशा मेटाडेटा की प्रस्तुति और इंटरनेट पर अन्य निर्देशों की जानकारी पा सकते हैं।



आरंभ करने के लिए, ऊपर दिए गए उदाहरण से कोड के भाग पर विचार करें:

 method.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Ldstr, "Inject!")); method.Body.Instructions.Insert(1, Instruction.Create(OpCodes.Call, writeLineRef));
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस कोड में, हमें कुछ विधि के CIL निर्देशों के एक सेट तक पहुँच मिली और अपना स्वयं का जोड़ें। आप CIL अनुदेश को यहाँ देख सकते हैं: सीआईएल के साथ सीधे काम करते समय, स्टैक महत्वपूर्ण है। हम स्टैक पर कुछ डेटा डाल सकते हैं और इसे वहां से ले सकते हैं (स्टैक के सिद्धांत के अनुसार)। ऊपर दिए गए उदाहरण में, Ldstr निर्देश का उपयोग करते हुए, हम स्टैक के आगे "Inject!" लाइन को धक्का देते हैं। इसके बाद, हम System.Console.WriteLine पर कॉल करते हैं। कोई भी विधि कॉल आवश्यक तर्क प्राप्त करने के लिए स्टैक तक पहुंचता है। इस स्थिति में, System.Console.WriteLine को स्ट्रिंग के तर्क की आवश्यकता होती है, जिसे हमने स्टैक पर लोड किया था। कॉल स्टेटमेंट अंत से तर्क लोड करता है, इसलिए आपको स्टैक पर तर्क मानों को सामान्य तरीके से लोड करने की आवश्यकता है। इस प्रकार, यह निर्देश "Inject!" के बराबर स्ट्रिंग के एक पैरामीटर के साथ System.Console.WriteLine विधि पर नियंत्रण स्थानांतरित करेगा। निर्देशों का यह सेट इसके बराबर है:

 System.Console.WriteLine("Injected!");
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

चूंकि Mono.Cecil विधानसभा को निर्देशों (बाइट्स) के एक सेट के रूप में मानता है, हम इसकी सामग्री को बिना किसी प्रतिबंध के बदल सकते हैं। CIL कोड जोड़ने के बाद, हम इसे सहेजते हैं (बाइट्स के एक सेट के रूप में) और एक संशोधित असेंबली प्राप्त करते हैं।

पहलू-उन्मुख दृष्टिकोण को लागू करने के लिए कोड पीढ़ी का वास्तविक अनुप्रयोग

उपरोक्त दृष्टिकोण को अपनी विधानसभाओं पर लागू करने पर विचार करें। बहुत बार हम किसी विधि में प्रवेश करते या बाहर निकलते समय कुछ कोड निष्पादित करना चाहते हैं, और विधि, या इसके संदर्भ का वर्णन करने वाले कुछ डेटा तक पहुंच प्राप्त करते हैं। सबसे सरल उदाहरण एक लकड़हारा है। यदि हम लॉग में प्रत्येक विधि के इनपुट और आउटपुट को लॉग करना चाहते हैं, तो प्रत्येक विधि के आरंभ और अंत में नीरस कोड लिखना बहुत थकाऊ हो सकता है। इसके अलावा, मेरी राय में, यह कुछ हद तक गंदा कोड है। इसके अलावा, हम स्वचालित रूप से स्टैक पर विधि के मापदंडों का उपयोग नहीं कर सकते हैं, और अगर हम इनपुट पर मापदंडों की स्थिति को रिकॉर्ड करना चाहते हैं, तो हमें इसे मैन्युअल रूप से करना होगा। दूसरी ज्ञात समस्या INotifyPropertyChanged का कार्यान्वयन है, जिसे प्रत्येक संपत्ति को मैन्युअल रूप से सौंपा जाना है।



एक अलग दृष्टिकोण पर विचार करें। इसका परीक्षण करने के लिए, एक नया कंसोल एप्लिकेशन बनाएं। एक वर्ग जोड़ें:

 [AttributeUsage(AttributeTargets.Method)] public class MethodInterceptionAttribute : Attribute { public virtual void OnEnter(System.Reflection.MethodBase method, Dictionary<string, object> parameters) { } public virtual void OnExit() { } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

एक उपयोगकर्ता इस वर्ग से इनहेरिट कर सकता है, ऑनएंटर विधि को ओवरराइड कर सकता है, और विरासत में मिली विशेषता को किसी भी विधि पर लागू कर सकता है। हमारा लक्ष्य निम्नलिखित अवसर का एहसास करना है: MethodInterceptionAttribute प्रकार की विशेषता के साथ चिह्नित विधि में प्रवेश करते समय, OnEnter को कॉल करें, जहां विधि का एक संदर्भ और <पैरामीटर नाम: मान> में इस पद्धति के मापदंडों का एक सेट पास करना है।



प्रयोगों के लिए, हम दो कंसोल एप्लिकेशन बनाएंगे। पहले में एक विशेषता परिभाषा होगी और कोड को तीसरे पक्ष के अनुप्रयोगों में इंजेक्ट करने के लिए आवश्यक सभी विधियां होंगी। दूसरे आवेदन का परीक्षण होगा। सबसे पहले, परीक्षण आवेदन के छोटे कोड पर विचार करें:

 class Program { static void Main(string[] args) { MethodToChange("Test"); } [TestMethodInterception()] public static void MethodToChange(string text) { Console.ReadLine(); } } public class TestMethodInterceptionAttribute : MethodInterceptionAttribute { public override void OnEnter(System.Reflection.MethodBase method, Dictionary<string, object> parameters) { Console.WriteLine("Entering method " + method.Name + "..." + Environment.NewLine); foreach (string paramName in parameters.Keys) { Console.WriteLine("Parameter " + paramName + " has value " + parameters[paramName] + Environment.NewLine); } } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह एक साधारण कंसोल एप्लिकेशन है जो टेस्ट के बराबर टेक्स्ट पैरामीटर के साथ MethodToChange विधि को कॉल करता है। यह विधि TestMethodInterceptionAttribute विशेषता MethodInterceptionAttribute से विरासत में मिली के साथ चिह्नित है। इस विशेषता के साथ चिह्नित किसी भी तरीके के बारे में जानकारी प्रदर्शित करने के लिए OnEnter को फिर से परिभाषित किया गया है। पूर्व-प्रसंस्करण के बिना, स्टार्टअप पर यह एप्लिकेशन Console.ReadLine को कॉल करेगा और बाहर निकल जाएगा।



हम मुख्य एप्लिकेशन (कंसोल भी) पर विचार जारी रखते हैं। MSIL कोड का एक उदाहरण प्रदर्शित करने और आगे के विकास में सहायता के लिए, हम निम्नलिखित सहायक विधि लिखेंगे:

 static void DumpAssembly(string path, string methodName) { System.IO.File.AppendAllText("dump.txt", "Dump started... " + Environment.NewLine); var assembly = AssemblyDefinition.ReadAssembly(path); foreach (var typeDef in assembly.MainModule.Types) { foreach (var method in typeDef.Methods) { if (String.IsNullOrEmpty(methodName) || method.Name == methodName) { System.IO.File.AppendAllText("dump.txt", "Method: " + method.ToString()); System.IO.File.AppendAllText("dump.txt", Environment.NewLine); foreach (var instruction in method.Body.Instructions) { System.IO.File.AppendAllText("dump.txt", instruction.ToString() + Environment.NewLine); } } } } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह विधि एक निर्माण विधि (या सभी) से मौजूदा MSIL कोड को पढ़ती है और इसे dip.txt पर लिखती है। यह कैसे उपयोगी हो सकता है? मान लीजिए कि हम जानते हैं कि तीसरे पक्ष की विधानसभा में हम क्या विशिष्ट कोड जोड़ना चाहते हैं, लेकिन सभी MSIL कोड को खरोंच से नहीं लिखना चाहते हैं। फिर हम अपने कुछ तरीकों को C # में इस कोड को लिखेंगे और इसे डंप करेंगे। उसके बाद, Mono.Cecil का उपयोग करके MSIL लिखना बहुत आसान हो जाएगा, पहले से ही तैयार उदाहरण है कि यह कैसा दिखेगा (निश्चित रूप से, MSIL असेंबली कोड को देखने के लिए अन्य अधिक सुविधाजनक तरीकों का उपयोग किया जा सकता है)।



विचार करें कि हम प्रत्येक विधि की शुरुआत में क्या प्राप्त करना चाहते हैं (C # के रूप में):

 var currentMethod = System.Reflection.MethodBase.GetCurrentMethod(); var attribute = (MethodInterceptionAttribute)Attribute.GetCustomAttribute(currentMethod, typeof(MethodInterceptionAttribute)); Dictionary<string, object> parameters = new Dictionary<string, object>(); //              parameters,    #   attribute.OnEnter(currentMethod, parameters);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस MSIL कोड को डंप करने का हिस्सा:



IL_0000: nop

IL_0001: call System.Reflection.MethodBase System.Reflection.MethodBase::GetCurrentMethod()

IL_0006: ldtoken EmitExperiments.MethodInterceptionAttribute

IL_000b: call System.Type System.Type::GetTypeFromHandle(System.RuntimeTypeHandle)

IL_0010: call System.Attribute System.Attribute::GetCustomAttribute(System.Reflection.MemberInfo,System.Type)

IL_0015: castclass EmitExperiments.MethodInterceptionAttribute

IL_001a: stloc V_1

IL_001e: ldloc V_1

IL_0022: callvirt System.Void EmitExperiments.MethodInterceptionAttribute::OnEnter()

...







अगला, मैं केवल InjectToAssembly विधि का पूरा कोड (विस्तृत टिप्पणियों के साथ) दूंगा, जो कि निर्दिष्ट विधानसभा के MethodInterceptionAttribute के साथ सभी तरीकों के लिए आवश्यक कोड जोड़ देगा:

 static void InjectToAssembly(string path) { var assembly = AssemblyDefinition.ReadAssembly(path); //   GetCurrentMethod() var getCurrentMethodRef = assembly.MainModule.Import(typeof(System.Reflection.MethodBase).GetMethod("GetCurrentMethod")); //   Attribute.GetCustomAttribute() var getCustomAttributeRef = assembly.MainModule.Import(typeof(System.Attribute).GetMethod("GetCustomAttribute", new Type[] { typeof(System.Reflection.MethodInfo), typeof(Type) })); //   Type.GetTypeFromHandle() -  typeof() var getTypeFromHandleRef = assembly.MainModule.Import(typeof(Type).GetMethod("GetTypeFromHandle")); //    MethodBase var methodBaseRef = assembly.MainModule.Import(typeof(System.Reflection.MethodBase)); //    MethodInterceptionAttribute var interceptionAttributeRef = assembly.MainModule.Import(typeof(MethodInterceptionAttribute)); //   MethodInterceptionAttribute.OnEnter var interceptionAttributeOnEnter = assembly.MainModule.Import(typeof(MethodInterceptionAttribute).GetMethod("OnEnter")); //    Dictionary<string,object> var dictionaryType = Type.GetType("System.Collections.Generic.Dictionary`2[System.String,System.Object]"); var dictStringObjectRef = assembly.MainModule.Import(dictionaryType); var dictConstructorRef = assembly.MainModule.Import(dictionaryType.GetConstructor(Type.EmptyTypes)); var dictMethodAddRef = assembly.MainModule.Import(dictionaryType.GetMethod("Add")); foreach (var typeDef in assembly.MainModule.Types) { foreach (var method in typeDef.Methods.Where(m => m.CustomAttributes.Where( attr => attr.AttributeType.Resolve().BaseType.Name == "MethodInterceptionAttribute").FirstOrDefault() != null)) { var ilProc = method.Body.GetILProcessor(); //   InitLocals  true,       false (      ) //      -  IL   . method.Body.InitLocals = true; //      attribute, currentMethod  parameters var attributeVariable = new VariableDefinition(interceptionAttributeRef); var currentMethodVar = new VariableDefinition(methodBaseRef); var parametersVariable = new VariableDefinition(dictStringObjectRef); ilProc.Body.Variables.Add(attributeVariable); ilProc.Body.Variables.Add(currentMethodVar); ilProc.Body.Variables.Add(parametersVariable); Instruction firstInstruction = ilProc.Body.Instructions[0]; ilProc.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Nop)); //    ilProc.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Call, getCurrentMethodRef)); //       currentMethodVar ilProc.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Stloc, currentMethodVar)); //        ilProc.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Ldloc, currentMethodVar)); //     MethodInterceptionAttribute ilProc.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Ldtoken, interceptionAttributeRef)); //  GetTypeFromHandle (   typeof()) -  typeof(MethodInterceptionAttribute) ilProc.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Call, getTypeFromHandleRef)); //          MethodInterceptionAttribute.  Attribute.GetCustomAttribute ilProc.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Call, getCustomAttributeRef)); //     MethodInterceptionAttribute ilProc.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Castclass, interceptionAttributeRef)); //     attributeVariable ilProc.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Stloc, attributeVariable)); //   Dictionary<stirng, object> ilProc.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Newobj, dictConstructorRef)); //   parametersVariable ilProc.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Stloc, parametersVariable)); foreach (var argument in method.Parameters) { //    //     Dictionary<string,object> ilProc.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Ldloc, parametersVariable)); //    ilProc.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Ldstr, argument.Name)); //    ilProc.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Ldarg, argument)); //  Dictionary.Add(string key, object value) ilProc.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Call, dictMethodAddRef)); } //     ,       OnEnter ilProc.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Ldloc, attributeVariable)); ilProc.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Ldloc, currentMethodVar)); ilProc.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Ldloc, parametersVariable)); //  OnEnter.     ,    OnEnter    ilProc.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Callvirt, interceptionAttributeOnEnter)); } } assembly.Write(path); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

हमारे कंसोल एप्लिकेशन की मुख्य विधि के बारे में मत भूलना:

 static void Main(string[] args) { if (args.Length > 0) { string mode = args[0]; string path = args[1]; if (mode == "-dump") { string methodName = args.Length > 2 ? args[2] : String.Empty; DumpAssembly(path, methodName); } else if (mode == "-inject") { InjectToAssembly(args[1]); } } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

हो गया! अब, यदि आप -inject पैरामीटर के साथ मुख्य एप्लिकेशन को चलाते हैं, तो यह हमारे टेस्ट एप्लिकेशन के लिए पथ को पारित करता है, MethodToChange विधि का कोड निम्नानुसार बदल जाएगा (रिफ्लेक्टर का उपयोग करके)

 [TestMethodInterception] public static void MethodToChange(string text) { MethodBase currentMethod = MethodBase.GetCurrentMethod(); MethodInterceptionAttribute customAttribute = (MethodInterceptionAttribute) Attribute.GetCustomAttribute(currentMethod, typeof(MethodInterceptionAttribute)); Dictionary<string, object> parameters = new Dictionary<string, object>(); parameters.Add("text", text); customAttribute.OnEnter(currentMethod, parameters); Console.ReadLine(); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

जिसकी आवश्यकता थी। अब, TestMethodInterception के साथ चिह्नित प्रत्येक विधि को इंटरसेप्ट किया जाएगा और प्रत्येक कॉल को कई बार दोहराया गया कोड लिखे बिना संसाधित किया जाएगा। प्रक्रिया को स्वचालित करने के लिए, आप वीएस में पोस्ट-बिल्ड इवेंट का उपयोग कर सकते हैं, ताकि किसी प्रोजेक्ट के सफल निर्माण के बाद, स्वचालित रूप से तैयार विधानसभा की प्रक्रिया करें और विशेषताओं के आधार पर कोड को लागू करें। आप कोड या असेंबली स्तर की विशेषताओं को एक साथ सभी क्लास या असेंबली विधियों में कोड एम्बेड करने के लिए भी बना सकते हैं।



यह दृष्टिकोण .NET में पहलू-उन्मुख प्रोग्रामिंग तकनीकों का उपयोग करने का एक उदाहरण है। मैं इस बात पर ध्यान नहीं दूंगा कि AOP क्या है, सामान्य शब्दों में आप इसके बारे में विकिपीडिया पर हमेशा पढ़ सकते हैं। सबसे प्रसिद्ध पुस्तकालय जो आपको .NET में AOP के सिद्धांतों का उपयोग करने की अनुमति देता है, वह PostSharp है , जिसने मुझे इस लेख को लिखते हुए समान कार्यक्षमता को लागू करने के लिए कोड को इंजेक्शन लगाने की संभावनाओं का अध्ययन करने के लिए प्रेरित किया।



एओपी का उपयोग करने से आप साफ और आसानी से बनाए रखा कोड लिख सकते हैं, इसका मुख्य कारण यह है कि अधिकांश कोड पहलुओं के आधार पर स्वचालित रूप से उत्पन्न होते हैं।



इस लेख में मैंने विस्तार से वर्णन करने का प्रयास किया कि आप Mono.Cecil का उपयोग करके मौजूदा नेट असेंबली में कोड कैसे जोड़ सकते हैं, साथ ही नेट में AOP सिद्धांतों को लागू करने के लिए इसका उपयोग कैसे किया जा सकता है, मुझे उम्मीद है कि यह कई के लिए दिलचस्प या उपयोगी होगा।