एक .Net वस्तु के लिए एक सूचक हो रही है

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

विधि संख्या 1

अनुसंधान कार्य के बाद यह पता चला कि संरचना के अंदर दो संदर्भ प्रकारों को रखना संभव है और साथ ही साथ एक दूसरे के शीर्ष पर सुपरइम्पोज़ करके संरचना की शुरुआत के सापेक्ष उनका सटीक संरेखण सेट करें। तो इस मामले में हमारे पास क्या है?

• संदर्भ प्रकार के किसी भी उदाहरण में सिस्टम जानकारी के साथ एक अकेला हेडर है।
• इसका मतलब यह है कि यदि हम अपनी कक्षा में एक क्षेत्र रखते हैं, और यदि हम किसी अन्य क्षेत्र में एक भी क्षेत्र को परिभाषित करते हैं, तो वे प्रत्येक कक्षा की शुरुआत के सापेक्ष एक ऑफसेट पर स्थित होंगे।
• यदि हमारे पास दो फ़ील्ड्स हैं, तो एक ही ऑफ़सेट के साथ दो प्रकारों में संदर्भ प्रकारों की जाँच की जा सकती है (`[StructLayout (LayoutKind.explicit)]` संरचना के प्रकार के विवरण पर और `[FieldOffset (0)]` को खेतों के विवरण पर), जबकि एक को लिखें इनमें से, कुछ कक्षा के लिए एक सूचक, फिर दूसरे क्षेत्र के साथ एक ही पॉइंटर (फ़ील्ड ऑफसेट समान है) का उल्लेख करते हुए, जिस प्रकार का एक ही समय में अपने स्वयं के क्षेत्रों के साथ एक अलग सामग्री होती है, हम उसी डेटा को अपने तरीके से व्याख्या करते हैं। दूसरे शब्दों में, यदि हमारे पास दो वर्ग हैं: `ए` और` बी`, और एक ही समय में, `ए` के पास फ़ील्ड` ऑब्जेक्ट _फ़ील्ड` है, और क्लास `बी` के पास फ़ील्ड` इंट _फील्ड` है, तो 32-बिट पर एक संरचना `C`, जिसमें एक एकल ऑफ़सेट में टाइप` A` और `B` के साथ फ़ील्ड हैं, आप इस ऑब्जेक्ट का पता पढ़ने के लिए` CA_field = नई ऑब्जेक्ट () `लिख सकते हैं:` var address = CB_field`।

उपरोक्त प्रदर्शित करने के लिए, SafePtr संरचना को लागू किया गया था, जिसमें सिर्फ दो आंतरिक प्रकार होते हैं: ReferenceType (1) और IntPtrWrapper (2) और उन्हें स्थापित करने और प्राप्त करने के लिए दो गुण - (5) और (6), जो एक ऑफसेट 0 (3) और (4) में संरेखित क्षेत्रों के मूल्यों को पढ़ते हैं और प्राप्त करते हैं:

[StructLayout(LayoutKind.Explicit)] public struct SafePtr { // (1) public class ReferenceType { public object Reference; } // (2) public class IntPtrWrapper { public IntPtr IntPtr; } // (3) [FieldOffset(0)] private ReferenceType Obj; // (4) [FieldOffset(0)] private IntPtrWrapper Pointer; public static SafePtr Create(object obj) { return new SafePtr { Obj = new ReferenceType { Reference = obj } }; } public static SafePtr Create(IntPtr rIntPtr) { return new SafePtr { Pointer = new IntPtrWrapper { IntPtr = rIntPtr } }; } // (5) public IntPtr IntPtr { get { return Pointer.IntPtr; } set { Pointer.IntPtr = value; } } // (6) public Object Object { get { return Obj.Reference; } set { Obj.Reference = value; } } public void SetPointer(SafePtr another) { Pointer.IntPtr = another.Pointer.IntPtr; } } 

और अंत में, का उपयोग:

  var safeptr = SafePtr.Create(new object()); Console.WriteLine("Address of object is: {0}", safeptr.IntPtr.ToInt32()); 

यह सब :) आप इसे एक साफ सूचक के रूप में भी उपयोग कर सकते हैं:

  var safeptr = SafePtr.Create(new object()); unsafe { ((int *)safeptr.IntPtr)* = 0; } Console.WriteLine("Address of object is null: {0}", safeptr.Object == null); 

विधि संख्या 2

एक और, अधिक सुविधाजनक तरीका है। कड़ाई से टाइप किए गए .net पॉइंटर को एक रेगुलर पॉइंटर में डालने के लिए, आपको एक ऐसी जगह ढूंढनी होगी, जहां टाइप की जानकारी गुम हो जाए। जहां यह सब वही हो जाता है जो संग्रहीत होता है। और ऐसी जगह है: एक धारा ढेर। .Net कॉल विधियों के लिए सामान्य स्ट्रीम स्टैक का उपयोग करता है (सामान्य तौर पर, इसे किसी और चीज़ का उपयोग क्यों करना चाहिए?), जिसका अर्थ है कि अगर .Net ऑब्जेक्ट के लिए एक पॉइंटर को वहां रखा गया है, जिसका आकार (उदाहरण के लिए) 32-बिट मशीन पर है। 4 बाइट्स, तो आप बस वहाँ से 4 बाइट्स पढ़ सकते हैं और यह बात है। मुख्य बात यह है कि संकलन पर JITTER प्रकारों की जांच नहीं करता है।

C # हमें स्टैक पर एक प्रकार के डेटा को पुश करने और एक और प्राप्त करने की अनुमति नहीं देता है। अर्थात्, दूसरे शब्दों में, निर्माण:

  int pointer = new Object(); 

यह निषिद्ध। हालाँकि, यह MSIL द्वारा निषिद्ध नहीं है। इस पर और रूपांतरण के तरीके (EntityPtr.il) लिखें:

 // Metadata version: v2.0.50215 .assembly extern mscorlib { .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 2:0:0:0 } .assembly EntityPtr { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .hash algorithm 0x00008004 .ver 1:0:0:0 } .module sample.exe // MVID: {A224F460-A049-4A03-9E71-80A36DBBBCD3} .imagebase 0x00400000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY // =============== CLASS MEMBERS DECLARATION =================== .class public auto ansi abstract sealed beforefieldinit System.Runtime.CLR.EntityPtr extends [mscorlib]System.Object { .method public hidebysig static native int ToPointer<TType> ( !!TType input ) cil managed { // Method begins at RVA 0x2254 // Code size 7 (0x7) .maxstack 2 .locals init ( [0] native int CSS ) ldarg.0 conv.i4 ldc.i4 4 sub conv.i ret } // end of method Converter::ToPointer .method public hidebysig static native int ToPointerWithOffset<TType> ( !!TType input ) cil managed { // Method begins at RVA 0x2254 // Code size 7 (0x7) .maxstack 2 .locals init ( [0] native int CSS ) ldarg.0 ret } // end of method Converter::ToPointer // Methods .method public hidebysig static !!TType ToInstance<TType> ( native int input ) cil managed { // Method begins at RVA 0x2254 // Code size 7 (0x7) .maxstack 2 .locals init ( [0] native int CSS ) ldarg.0 conv.i4 ldc.i4 4 add conv.i ret } // end of method Converter::ToInstance .method public hidebysig static !!TType ToInstanceWithOffset<TType> ( native int input ) cil managed { // Method begins at RVA 0x2254 // Code size 7 (0x7) .maxstack 2 .locals init ( [0] native int CSS ) ldarg.0 ret } // end of method Converter::ToInstance } // end of class sandbox.Converter 

इस कोड में अनिवार्य रूप से `System.Runtime.CLR.EntityPtr` वर्ग चार विधियों के साथ है:

• IntPtr ToPointer (T ऑब्जेक्ट) - SyncBlockIndex के आकार द्वारा स्थानांतरित किए गए ऑब्जेक्ट के लिए एक पॉइंटर लौटाता है (.Net में संकेत इंगित करता है कि ऑब्जेक्ट की शुरुआत इंगित नहीं करता है, लेकिन SynclocklockIndex के बराबर ऑफसेट के साथ लिया जाता है, अर्थात प्रोसेसर शब्द के आकार के बराबर)।
  IntPtr ToPointerWithOffset (T ऑब्जेक्ट) - SyncBlockIndex के आकार से ऑफसेट के बिना किसी ऑब्जेक्ट को पॉइंटर लौटाता है
  T Tostance (IntPtr पॉइंटर) - पॉइंटर द्वारा बताए गए ऑब्जेक्ट को शब्द के आकार द्वारा वापस लौटा दिया जाता है (SyncBlockIndex)
  T ToPointerWithOffset (IntPtr पॉइंटर) - उस ऑब्जेक्ट को लौटाता है जो पॉइंटर शब्द के आकार को वापस लिए बिना इंगित करता है (SyncBlockIndex)
  
  और इसका उपयोग विधि 1 की तुलना में और भी सरल है:
  

    var pointer = EntityPtr.ToPointer("Hello"); 

  
  बस इतना ही!
  
  

  निष्कर्ष

  
  किए गए कार्य से, कई निष्कर्ष निकाले जा सकते हैं:
  
  • .Net ऑब्जेक्ट के लिए एक पॉइंटर प्राप्त किया जा सकता है
  • वास्तव में, दोनों तकनीक केवल फुलट्रस्ट में काम करती हैं। यदि आप सैंडबॉक्स को कॉन्फ़िगर करते हैं, तो एक अपवाद फेंक दिया जाएगा।
  • यदि जोड़तोड़ के दौरान जीसी काम करता है, तो मेमोरी, निश्चित रूप से, संपीड़ित होगी। उसी समय, हमारा सूचक स्वचालित रूप से वैध होने से बच जाएगा।
  
  हालांकि, यह इस तथ्य को नकारता नहीं है कि यह बेहद दिलचस्प है और नए अवसरों के टन को खोलता है।