अनिर्दिष्ट सुविधाओं के अनियंत्रित विशेषताएं: दूसरे थ्रेड में रेफिंग

प्रश्न मेरे साथ कभी नहीं हुआ: " लिंक को किसी अन्य स्ट्रीम में फ़ील्ड में कैसे सहेजना / स्थानांतरित करना है? " तार्किक धारणा यह है कि “मैं विधि को रेफ पास करूंगा और उसे बचाऊंगा। रुक जाओ, ओह शि ~। " हां, Refs सहेजे नहीं गए हैं (और फिर भी, आप उन पर क्लोज़र का उपयोग नहीं कर सकते हैं, इसलिए ऐसी विधि के अंदर फ़ंक्शन बनाना और इससे स्ट्रीम बनाना भी विफल हो जाएगा)। लेकिन आप अनिर्दिष्ट कीवर्ड __makeref के साथ TypedReference में बदल सकते हैं। काश, TypedReference सीधे क्षेत्र में संग्रहीत नहीं किया जा सकता है और System.Object से विरासत में नहीं मिलता है, इसलिए सामान्य तरीकों के साथ कास्टिंग भी असंभव है (और वास्तव में प्रतिबंधों का एक पूरा गुच्छा उनके उपयोग पर लगाया जाता है)। यह एक मृत अंत प्रतीत होगा। लेकिन यह सब नहीं है - वहाँ अभी भी एक RuntimeArgumentHandle है, जिसमें TypedReference गुण हैं, एक अपवाद के साथ - System.Object में एक मुश्किल डाली के बाद, आप अभी भी इसे तब तक उपयोग कर सकते हैं जब तक कि यह जिस स्टैक में बनाया गया था वह जीवित है। इस पोस्ट के बारे में।

TypedReference

TypedReference अपने आप में एक अद्भुत छोटी चीज़ है - आप इसमें Ref को लपेट सकते हैं और दूसरी विधि (यानी, एक विधि से, जिसमें से एक पैरामीटर ref 'ohm है) पास कर सकते हैं। हालांकि, इस संरचना के तरीके हमें एक मूल्य निर्धारित करने की अनुमति नहीं देते हैं - NotSupportedException हमें उम्मीद है कि हम उचित तरीकों को कॉल करेंगे। लेकिन इससे कोई फर्क नहीं पड़ता है - __refvalue कीवर्ड है, जो न केवल मूल्य प्राप्त करने की अनुमति देता है, बल्कि इसे सेट करने के लिए भी है। लेकिन यह अजीब लग रहा है:

void Out(ref int someInt) { Input(__makeref(someInt)); } void Input(TypedReference @ref) { int val = __refvalue(@ref, int);//  __refvalue(@ref, int) = 0;//   someInt } 

इस तथ्य के बावजूद कि प्रकार हैंडल द्वारा सेट किया गया है, यह सहेजने के लिए काम नहीं करेगा, उदाहरण के लिए, स्ट्रिंग में इंट - टाइप से संबंधित का सत्यापन फिर भी किया जाता है।
यह सब है, टाइप-रेफरेंस का उपयोग या तो बंद करने में नहीं किया जा सकता है - इसलिए टाइपराइटर पर क्लोजर के साथ कुछ बनाने के लिए, यह भी काम नहीं करेगा।

RuntimeArgumentHandle

यह केवल प्रोफाइल में, कुछ भी नहीं है। वास्तव में, यह TypedReference की सूची है (जिस तक ArgIterator का निर्माण करके काम किया जाता है), लेकिन यह भी बनाया गया है ... मुझे यह भी नहीं पता कि इसका वर्णन कैसे करें:

 void Out(int something) { Input(__arglist(something)); } void Input(__arglist) { new ArgIterator(__arglist); } 

उसी समय, __arglist कीवर्ड का उपयोग प्रतिनिधियों में नहीं किया जा सकता है जब वे घोषित किए जाते हैं। लेकिन RuntimeArgumentHandle संभव है (लेकिन केवल पैरामीटर के रूप में, TypedReference और RuntimeArgumentHandle को विधियों से वापस नहीं किया जा सकता है)। __arglist () का उपयोग किसी प्रतिनिधि को बुलाने के तर्क के रूप में भी नहीं किया जा सकता है, लेकिन __arlist को संभव है। कुछ हद तक अस्पष्ट शब्द का अर्थ एक उदाहरण द्वारा समर्थित है:

 delegate void ArgWarrior(RuntimeArgumentHandle argh); void Out(int something) { (new ArgWarrior(u => { } ))(__arglist(someting));//  Input(new ArgWarrior(u => { } ), __arglist(someting); } void Input(ArgWarrior argh, __arglist) { argh(__arglist);//   } 

और इसलिए मुझे इस मार्लेज़ोन बैले के प्रमुख बिंदु पर मिला: प्रतिनिधि।

एक तरह से अति सुंदर मॉकिंग प्रतिनिधियों के रूप में _methodPtrAux का हेरफेर

_methodPtrAux किसी भी प्रत्यायित प्रकार में चौथा क्षेत्र है, जो यहाँ एक महत्वपूर्ण भूमिका निभाएगा। क्या कहना है? लब्बोलुआब यह है कि _methodPtrAux एक पॉइंटर को पहले से ही जिट विधि में संग्रहीत करता है। उस सूचक द्वारा एक मनमाने ढंग से अप्रबंधित कोड लिखे जाने के बाद, हम इस अप्रबंधित कोड को निष्पादित कर सकते हैं। लेकिन यह बात नहीं है। प्रतिनिधि _methodPtrAux का मान बदलने के बाद भी प्रयोग करने योग्य रहता है, और जब इसे कॉल किया जाता है, तो नियंत्रण ठीक उसी स्थान पर जाएगा जहां इस फ़ील्ड का मान इंगित करता है। इस प्रकार, विभिन्न इनपुट मापदंडों के साथ दो प्रतिनिधि होने पर, मैं प्रतिनिधि से सूचक को प्रतिस्थापित कर सकता हूं, प्रतिनिधि b से सूचक के साथ। भले ही उनके पास तर्क का एक अलग सेट हो, लेकिन सब कुछ काम करेगा। मुख्य बिंदु यह होगा कि संबंधित तर्कों के प्रकार अलग-अलग होने पर भी, clr अलार्म नहीं बजाएगा - int को स्ट्रिंग में डाल दिया जाएगा , सभी इच्छाएं पूरी हो जाएंगी, कोई भी नाराज नहीं होगा , या ... RuntimeArgumentHolle को System.Object में परिवर्तित किया जाएगा:

  delegate void Encast(RuntimeArgumentHandle @ref); delegate void Uncast(object @object); static void UseWith(Encast en, __arglist) { en(__arglist); } static object m_storedRef; static void Engage(ref object @object) { Encast en = new Encast(@ref => { }); Uncast un = new Uncast(o => { m_storedRef = o;//     <b>en</b>. }); typeof(Encast).GetFields(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)[3].SetValue(en, typeof(Uncast).GetFields(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)[3].GetValue(un));//   en UseWith(en, __arglist(__makeref(@object))); // } 

जैसा कि आप मेमने से देख सकते हैं, मैं तुरंत एक स्थिर क्षेत्र में परिणामी मूल्य को बचाता हूं। हां, एक अक्षम्य सीमा है - यदि आप गैर-स्थिर क्षेत्र में ओ को बचाते हैं, तो आप clr (रीड-राइट प्रोटेक्टेड मेमोरी) को छोड़ सकते हैं। भले ही लक्ष्य फ़ील्ड एक फ़ील्ड नहीं है, लेकिन एक ऑब्जेक्ट फ़ील्ड जो एक स्थिर फ़ील्ड में संग्रहीत है (उदाहरण के लिए, शब्दकोश) सब कुछ आसानी से जाना चाहिए। इसी समय, लैम्ब्डा तर्क डिबगर में कुछ अजीब लगता है: देखते समय, आप केवल "{ऑब्जेक्ट}" (बिना उद्धरण के) देख सकते हैं और कुछ भी नहीं। स्ट्रिंग को एक प्रकार या कास्ट निकालने की कोशिश करना अच्छी तरह से नहीं झुकता है (आप clr को छोड़ सकते हैं)
उलटा परिवर्तन इसी तरह से किया जाता है। स्टैक फ्रेम को सहेजना मॉनिटर का उपयोग करके किया जाता है:

  static object m_locker = new object(); //... Monitor.Enter(m_locker); Monitor.Exit(m_locker); 

m_locker पहले से ही एक और धागे से अवरुद्ध है, इसलिए निष्पादन रोक दिया गया है, अर्थात। RuntimeArgumentHandle बिना ब्रेक के स्टैक पर बनी हुई है।
पूरा कार्यक्रम कोड इस तरह दिखता है:

 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; namespace ThreadJiggler { class Program { delegate void Encast(RuntimeArgumentHandle @ref); delegate void Uncast(object @object); static object m_storedRef; static object m_locker = new object(); static bool m_useFlag; static void Main(string[] args) { object @v = "means \"vendetta\""; Victim1(ref @v); Console.WriteLine(@v); } static void UseWith(Encast en, __arglist) { en(__arglist); } static Thread m_someThread; static void Victim1(ref object @object) { Thread t = new Thread(() => { Monitor.Enter(m_locker); { for (; !m_useFlag; ) { Thread.Sleep(10); } Encast en = new Encast(@ref => { TypedReference tr = new ArgIterator(@ref).GetNextArg(); __refvalue( tr, object) = 0; }); Uncast un = new Uncast(o => { m_storedRef = o; }); typeof(Uncast).GetFields(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)[3].SetValue(un, typeof(Encast).GetFields(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)[3].GetValue(en)); un(m_storedRef); } Monitor.Exit(m_locker); }); t.IsBackground = false; t.Start(); { Encast en = new Encast(@ref => { }); Uncast un = new Uncast(o => { m_storedRef = o; m_useFlag = true; Monitor.Enter(m_locker); Monitor.Exit(m_locker); }); typeof(Encast).GetFields(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)[3].SetValue(en, typeof(Uncast).GetFields(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)[3].GetValue(un)); UseWith(en, __arglist(__makeref(@object))); } } } } 

मेन के अंत में , आप देख सकते हैं कि @v का मान 0 में बदल गया है।