C# एक अविश्वसनीय रूप से लचीली भाषा है। उस पर आप न केवल बैकएंड या डेस्कटॉप एप्लिकेशन लिख सकते हैं। मैं वैज्ञानिक डेटा के साथ काम करने के लिए C# का उपयोग करता हूं, जो भाषा में उपलब्ध उपकरणों पर कुछ आवश्यकताओं को लागू करता है। हालाँकि netcore netstandard2.0 एजेंडा पर है (यह मानते हुए कि netstandard2.0 बाद दोनों भाषाओं और रनटाइम की अधिकांश सुविधाएँ netframework को netframework नहीं netframework ), मैं विरासत परियोजनाओं के साथ काम करना जारी रखता हूं।

इस लेख में, मैं एक गैर-स्पष्ट (लेकिन शायद वांछित?) Span<T> आवेदन पर विचार करता हूं Span<T> और clr की बारीकियों के कारण netframework और netframework में Span<T> के कार्यान्वयन के बीच का अंतर।

मुझे Span<T> आवश्यकता क्यों है?

Spen आपको अधिक सुविधाजनक रूप में unmanaged प्रकारों के सरणियों के साथ काम करने की अनुमति देता है, जिससे आवश्यक आवंटन की संख्या कम हो जाती है। इस तथ्य के बावजूद कि BCL netframework में स्पैन का समर्थन लगभग पूरी तरह से अनुपस्थित है, System.Memory , System.Buffers और System.Runtime.CompilerServices.Unsafe का System.Memory करके कई उपकरण प्राप्त किए जा सकते हैं।
मेरी विरासत परियोजना में स्पैन का उपयोग सीमित है, हालांकि, मैंने उन्हें एक स्पष्ट उपयोग पाया, जबकि प्रकार की सुरक्षा पर थूकना।
यह आवेदन क्या है? अपनी परियोजना में मैं एक वैज्ञानिक उपकरण से प्राप्त डेटा के साथ काम करता हूं। ये छवियां हैं, जो सामान्य रूप से, T[] की एक सरणी हैं, जहां T , unmanaged आदिम प्रकारों में से एक है, उदाहरण के लिए Int32 (उर्फ int )। इन छवियों को डिस्क पर सही ढंग से क्रमबद्ध करने के लिए, मुझे अविश्वसनीय रूप से असुविधाजनक विरासत प्रारूप का समर्थन करने की आवश्यकता है, जिसे 1981 में प्रस्तावित किया गया था, और तब से थोड़ा बदल गया है। इस प्रारूप की मुख्य समस्या यह है कि बिगइंडियन । इस प्रकार, T[] एक असम्पीडित सरणी को लिखने (या पढ़ने) के लिए, आपको प्रत्येक तत्व की समाप्ति को बदलने की आवश्यकता है। तुच्छ कार्य।
कुछ स्पष्ट समाधान क्या हैं?

1. हम सरणी T[] पर पुनरावृति करते हैं, BitConverter.GetBytes(T) कॉल करें, इन कुछ बाइट्स का विस्तार करें, लक्ष्य सरणी में कॉपी करें।
2. हम सरणी T[] पर पुनरावृत्ति करते हैं, new byte[] {(byte)((x & 0xFF00) >> 8), (byte)(x & 0x00FF)}; (डबल-बाइट प्रकार पर काम करना चाहिए), लक्ष्य सरणी पर लिखें।
3. ^* लेकिन T[] एक सरणी है? तत्व एक पंक्ति में हैं, है ना? तो आप सभी तरह से जा सकते हैं, उदाहरण के लिए, Buffer.BlockCopy(intArray, 0, byteArray, 0, intArray.Length * sizeof(int)); । विधि सरणी को चेकिंग प्रकार की अनदेखी कर सरणी को कॉपी करती है। यह केवल सीमाओं और आवंटन को याद नहीं करने के लिए आवश्यक है। हम परिणामस्वरूप बाइट्स को मिलाते हैं।
4. ^* वे कहते हैं कि C# (C++)++ । इसलिए, सक्षम /unsafe , fixed(int* p = &intArr[0]) byte* bPtr = (byte*)p; और अब आप स्रोत सरणी के बाइट प्रतिनिधित्व के चारों ओर दौड़ सकते हैं, मक्खी पर धीरज को बदल सकते हैं और एक पूरी नई बाइट सरणी के लिए मेमोरी आवंटित किए बिना डिस्क ( stackalloc byte[] या ArrayPool<byte>.Shared ) को इंटरमीडिएट बफर के लिए ब्लॉक लिख सकते हैं।

ऐसा लगता है कि बिंदु 4 आपको सभी समस्याओं को हल करने की अनुमति देता है, लेकिन unsafe संदर्भ और संकेत के साथ काम करने का स्पष्ट उपयोग किसी तरह पूरी तरह से अलग है। फिर Span<T> हमारी सहायता के लिए आता है।

Span<T>

Span<T> को तकनीकी रूप से स्मृति बिंदुओं के साथ काम करने के लिए उपकरण प्रदान करना चाहिए, जैसे कि पॉइंटर्स के माध्यम से काम करना, स्मृति में सरणी को "ठीक" करने की आवश्यकता को समाप्त करना। सरणी सीमाओं के साथ इस तरह के GC सावधान सूचक। सब कुछ ठीक और सुरक्षित है।
एक बात लेकिन - System.Runtime.CompilerServices.Unsafe की संपत्ति के बावजूद, Span<T> टाइप T लिए किसी को नहीं T यह देखते हुए कि स्पैन अनिवार्य रूप से ¹ + लंबाई सूचक है, क्या होगा यदि आप अपने पॉइंटर को बाहर निकालते हैं, इसे किसी अन्य प्रकार में परिवर्तित करते हैं, लंबाई को पुनर्गणना करते हैं और एक नया स्पैन बनाते हैं? सौभाग्य से, हमारे पास public Span<T>(void* pointer, int length) ।
आइए एक साधारण परीक्षण लिखें:

 [Test] public void Test() { void Flip(Span<byte> span) {/*   endianess */} Span<int> x = new [] {123}; Span<byte> y = DangerousCast<int, byte>(x); Assert.AreEqual(123, x[0]); Flip(y); Assert.AreNotEqual(123, x[0]); Flip(y); Assert.AreEqual(123, x[0]); } 

मेरे से अधिक उन्नत डेवलपर्स को तुरंत महसूस करना चाहिए कि यहां क्या गलत है। क्या परीक्षा में फेल हो जाएंगे? उत्तर, जैसा कि आमतौर पर होता है, निर्भर करता है ।
इस मामले में, यह मुख्य रूप से रनटाइम पर निर्भर करता है। netframework पर, परीक्षण को काम करना चाहिए , लेकिन netframework पर, यह कैसे netframework ।
दिलचस्प है, यदि आप कुछ निबंधों को हटाते हैं, तो परीक्षण 100% मामलों में सही तरीके से काम करना शुरू कर देता है।
चलो ठीक है।

¹ मैं गलत था ।

सही उत्तर: निर्भर करता है

परिणाम निर्भर क्यों करता है?
आइए सभी अनावश्यक हटा दें और यहां इस तरह का कोड लिखें:

 private static void Main() => Check(); private static void Check() { Span<int> x = new[] {999, 123, 11, -100}; Span<byte> y = As<int, byte>(ref x); Console.WriteLine(@"FRAMEWORK_NAME"); Write(ref x); Write(ref y); Console.WriteLine(); Write<int, int>(ref x, "Span<int> [0]"); Write<byte, int>(ref y, "Span<byte>[0]"); Console.WriteLine(); Write<int, int>(ref Offset<int, object>(ref x[0], 1), "Span<int> [0] offset by size_t"); Write<byte, int>(ref Offset<byte, object>(ref y[0], 1), "Span<byte>[0] offset by size_t"); Console.WriteLine(); GC.Collect(0, GCCollectionMode.Forced, true, true); Write<int, int>(ref x, "Span<int> [0] after GC"); Write<byte, int>(ref y, "Span<byte>[0] after GC"); Console.WriteLine(); Write(ref x); Write(ref y); } 

Write<T, U> विधि टाइप T की अवधि को स्वीकार करता है, पहले तत्व का पता पढ़ता है, और इस सूचक के माध्यम से टाइप U का एक तत्व पढ़ता है। दूसरे शब्दों में, Write<int, int>(ref x) मेमोरी में एड्रेस + नंबर 999 को आउटपुट करेगा।
सामान्य Write एक सरणी प्रिंट।
अब As<,> विधि के बारे में:

  private static unsafe Span<U> As<T, U>(ref Span<T> span) where T : unmanaged where U : unmanaged { fixed(T* ptr = span) return new Span<U>(ptr, span.Length * Unsafe.SizeOf<T>() / Unsafe.SizeOf<U>()); } 

C# सिंटैक्स अब निश्चित रूप से Span<T>.GetPinnableReference() विधि को कॉल करके इस निश्चित-राज्य रिकॉर्ड का समर्थन करता है।
इस विधि को x64 मोड में netframework4.8 पर चलाएँ। हम देखते हैं कि क्या होता है:

 LEGACY [ 999, 123, 11, -100 ] [ 231, 3, 0, 0, 123, 0, 0, 0, 11, 0, 0, 0, 156, 255, 255, 255 ] 0x|00|00|02|8C|00|00|2F|B0 999 Span<int> [0] 0x|00|00|02|8C|00|00|2F|B0 999 Span<byte>[0] 0x|00|00|02|8C|00|00|2F|B8 11 Span<int> [0] offset by size_t 0x|00|00|02|8C|00|00|2F|B8 11 Span<byte>[0] offset by size_t 0x|00|00|02|8C|00|00|2B|18 999 Span<int> [0] after GC 0x|00|00|02|8C|00|00|2F|B0 6750318 Span<byte>[0] after GC [ 999, 123, 11, -100 ] [ 110, 0, 103, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] 

प्रारंभ में, दोनों स्पैन (विभिन्न प्रकारों के बावजूद) समान रूप से व्यवहार करते हैं, और Span<byte> , संक्षेप में, मूल सरणी के बाइट-व्यू का प्रतिनिधित्व करता है। आपको क्या चाहिए
ठीक है, चलो स्पैन की शुरुआत को एक IntPtr (या x64 पर 2 X int ) के आकार में स्थानांतरित करने की कोशिश करें और पढ़ें। हमें सरणी का तीसरा तत्व और सही पता मिलता है। और फिर हम कचरा इकट्ठा करेंगे ...

 GC.Collect(0, GCCollectionMode.Forced, true, true); 

इस विधि में अंतिम ध्वज GC ढेर GC कॉम्पैक्ट GC कहता है। GC.Collect कॉल करने के बाद GC.Collect GC मूल स्थानीय सरणी को स्थानांतरित करता है। Span<int> इन परिवर्तनों को दर्शाता है, लेकिन हमारा Span<byte> पुराने पते को इंगित करता है, जहां अब यह स्पष्ट नहीं है कि क्या है। एक बार में अपने आप को अपने सभी घुटनों को शूट करने का एक शानदार तरीका!

अब हम netcore3.0.100-preview8 पर कॉल किए गए सटीक समान कोड टुकड़े के परिणाम को netcore3.0.100-preview8 ।

 CORE [ 999, 123, 11, -100 ] [ 231, 3, 0, 0, 123, 0, 0, 0, 11, 0, 0, 0, 156, 255, 255, 255 ] 0x|00|00|01|F2|8F|BD|C6|90 999 Span<int> [0] 0x|00|00|01|F2|8F|BD|C6|90 999 Span<byte>[0] 0x|00|00|01|F2|8F|BD|C6|98 11 Span<int> [0] offset by size_t 0x|00|00|01|F2|8F|BD|C6|98 11 Span<byte>[0] offset by size_t 0x|00|00|01|F2|8F|BD|BF|38 999 Span<int> [0] after GC 0x|00|00|01|F2|8F|BD|BF|38 999 Span<byte>[0] after GC [ 999, 123, 11, -100 ] [ 231, 3, 0, 0, 123, 0, 0, 0, 11, 0, 0, 0, 156, 255, 255, 255 ] 

सब कुछ काम करता है, और यह पूरी तरह से काम करता है, जहां तक ​​मैं देख सकता हूं। संघनन के बाद, दोनों शुक्राणु अपने सूचक को बदलते हैं। बहुत बढ़िया! लेकिन अब इसे एक विरासत परियोजना में कैसे काम किया जाए?

जित आंतरिक

मैं बिल्कुल भूल गया कि स्पैन के लिए समर्थन को आंतरिक रूप से netcore में लागू किया जाता है । दूसरे शब्दों में, netcore एक सरणी के टुकड़े तक भी आंतरिक पॉइंटर्स बना सकता है और GC ले जाने पर लिंक को सही ढंग से अपडेट कर सकता है। netframework , netframework का nuget कार्यान्वयन एक बैसाखी है। वास्तव में, हमारे पास दो अलग-अलग स्पैन हैं: एक एरे से बनाया गया है और इसके लिंक को ट्रैक करता है, दूसरा पॉइंटर से और इसका कोई अंदाजा नहीं है कि यह किस ओर इशारा करता है। मूल सरणी को स्थानांतरित करने के बाद, स्पैन पॉइंटर को इंगित करना जारी रहता है कि पॉइंटर अपने कंस्ट्रक्टर में कहां से गुजरा है। तुलना के लिए, यह netcore में अवधि का एक उदाहरण कार्यान्वयन है:

 readonly ref struct Span<T> where T : unmanaged { private readonly ByReference<T> _pointer; //  -   private readonly int _length; } 

और netframework :

 readonly ref struct Span<T> where T : unmanaged { private readonly Pinnable<T> _pinnable; private readonly IntPtr _byteOffset; private readonly int _length; } 

_pinnable में सरणी के लिए एक संदर्भ होता है, यदि किसी को निर्माणकर्ता को पास किया गया था, _byteOffset में एक बदलाव होता है (यहां तक ​​कि पूरे सरणी में कुछ गैर-शून्य पारी है जिस तरह से सरणी को मेमोरी में दर्शाया जाता है, शायद )। यदि आप निर्माता को void* पॉइंटर पास करते हैं, तो यह केवल एक निरपेक्ष _byteOffset परिवर्तित हो जाता है। स्पैन को मेमोरी क्षेत्र में तंग किया जाएगा, और सभी उदाहरण विधियाँ शर्तों के साथ लाजिमी हैं जैसे if(_pinnable is null) {/* */} else {/* _pinnable */} । ऐसी स्थिति में क्या करें?

यह कैसे करना है यह इसके लायक नहीं है, लेकिन मैंने अभी भी किया है

यह खंड netframework द्वारा समर्थित विभिन्न कार्यान्वयनों के लिए समर्पित है, जो Span<T> -> Span<U> को सभी आवश्यक लिंक रखते हुए netframework अनुमति देते हैं।
मैं आपको चेतावनी देता हूं: यह संभवतः मौलिक त्रुटियों और अंत में एक अपरिभाषित व्यवहार के साथ असामान्य प्रोग्रामिंग का एक क्षेत्र है

विधि 1: Naive

जैसा कि उदाहरण से पता चला है, पॉइंटर्स का रूपांतरण netframework पर वांछित परिणाम नहीं देगा। हमें _pinnable value चाहिए। ठीक है, हम निजी क्षेत्रों (बहुत बुरा और हमेशा संभव नहीं) को बाहर निकालकर प्रतिबिंब को उजागर करेंगे, हम इसे एक नई स्पैन में लिखेंगे, हम खुश होंगे। केवल एक छोटी सी समस्या है: स्पैन एक ref struct , यह न तो एक सामान्य तर्क हो सकता है, न ही इसे किसी object में पैक किया जा सकता है। प्रतिबिंब के मानक तरीकों को स्पैन को संदर्भ प्रकार में धकेलने के लिए एक या दूसरे तरीके की आवश्यकता होगी। मुझे एक सरल तरीका नहीं मिला (यहां तक ​​कि निजी क्षेत्रों पर प्रतिबिंब पर विचार करते हुए)।

विधि 2: हमें गहराई तक जाने की आवश्यकता है

मेरे ( [1] , [२] , [३] ) से पहले ही सब कुछ हो चुका है। स्पेन एक संरचना है, T परवाह किए बिना T तीन फ़ील्ड मेमोरी की समान मात्रा ( समान आर्किटेक्चर पर ) पर कब्जा कर लेते हैं। क्या होगा अगर [FieldOffset(0)] ? जल्दी से नहीं कहा।

 [StructLayout(LayoutKind.Explicit)] ref struct Exchange<T, U> where T : unmanaged where U : unmanaged { [FieldOffset(0)] public Span<T> Span_1; [FieldOffset(0)] public Span<U> Span_2; } 

लेकिन जब आप प्रोग्राम शुरू करते हैं (या बल्कि, जब एक प्रकार का उपयोग करने का प्रयास करते हैं), तो TypeLoadException मिलती TypeLoadException - एक जेनेरिक LayoutKind.Explicit नहीं हो सकता है। LayoutKind.Explicit । ठीक है, कोई बात नहीं, चलो मुश्किल रास्ते पर चलते हैं:

 [StructLayout(LayoutKind.Explicit)] public ref struct Exchange { [FieldOffset(0)] public Span<byte> ByteSpan; [FieldOffset(0)] public Span<sbyte> SByteSpan; [FieldOffset(0)] public Span<ushort> UShortSpan; [FieldOffset(0)] public Span<short> ShortSpan; [FieldOffset(0)] public Span<uint> UIntSpan; [FieldOffset(0)] public Span<int> IntSpan; [FieldOffset(0)] public Span<ulong> ULongSpan; [FieldOffset(0)] public Span<long> LongSpan; [FieldOffset(0)] public Span<float> FloatSpan; [FieldOffset(0)] public Span<double> DoubleSpan; [FieldOffset(0)] public Span<char> CharSpan; } 

अब आप यह कर सकते हैं:

 private static Span<byte> As2(Span<int> span) { var exchange = new Exchange() { IntSpan = span }; return exchange.ByteSpan; } 

विधि केवल एक समस्या के साथ काम करती है - _length क्षेत्र _length नकल की जाती है, इसलिए जब int -> byte कास्टिंग करते हैं, तो बाइट स्पैन वास्तविक सरणी से 4 गुना छोटा होता है।
कोई समस्या नहीं:

 [StructLayout(LayoutKind.Sequential)] public ref struct Raw { public object Pinnable; public IntPtr Pointer; public int Length; } [StructLayout(LayoutKind.Explicit)] public ref struct Exchange { /* */ [FieldOffset(0)] public Raw RawView; } 

अब RawView माध्यम से आप प्रत्येक व्यक्तिगत स्पैन फ़ील्ड तक पहुंच सकते हैं।

 private static Span<byte> As2(Span<int> span) { var exchange = new Exchange() { IntSpan = span }; var exchange2 = new Exchange() { RawView = new Raw() { Pinnable = exchange.RawView.Pinnable, Pointer = exchange.RawView.Pointer, Length = exchange.RawView.Length * sizeof<int> / sizeof<byte> } }; return exchange2.ByteSpan; } 

और यह वैसे ही काम करता है, जैसे कि अगर आप गंदे चालों के इस्तेमाल को नजरअंदाज करते हैं। माइनस - कनवर्टर का सामान्य संस्करण नहीं बनाया जा सकता है, आपको पूर्वनिर्धारित प्रकारों से संतोष करना होगा।

विधि 3: पागल

किसी भी सामान्य प्रोग्रामर की तरह, मुझे चीजों को स्वचालित करना पसंद है। किसी भी प्रकार के unmanaged प्रकारों के लिए कन्वर्टर्स लिखने की आवश्यकता ने मुझे खुश नहीं किया। क्या समाधान पेश किया जा सकता है? यह सही है, आपके लिए कोड लिखने के लिए CLR प्राप्त करें।

इसे कैसे प्राप्त किया जाए? अलग-अलग तरीके हैं, लेख हैं । संक्षेप में, प्रक्रिया इस तरह दिखती है:
एक बिल्ड बिल्डर बनाएं -> एक मॉड्यूल बिल्डर बनाएं -> एक प्रकार का निर्माण करें -> {फील्ड्स, मेथड्स, आदि} -> आउटपुट पर हमें Type का एक उदाहरण मिलता है।
यह समझने के लिए कि प्रकार क्या होना चाहिए (यह एक ref struct ), हम ildasm प्रकार के किसी भी उपकरण का उपयोग करते हैं। मेरे मामले में, यह डॉटपेक था।
एक प्रकार का बिल्डर बनाना कुछ इस तरह दिखता है:

 var typeBuilder = _mBuilder.DefineType($"Generated_{typeof(T).Name}", TypeAttributes.Public | TypeAttributes.Sealed | TypeAttributes.ExplicitLayout // <-    | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit, typeof(ValueType)); 

अब खेत। चूँकि हम Span<T> को Span<U> सीधे कॉपी नहीं कर सकते हैं, क्योंकि लंबाई में अंतर के कारण, हमें प्रत्येक कास्ट के दो प्रकार बनाने होंगे

 [StructLayout(LayoutKind.Explicit)] ref struct Generated_Int32 { [FieldOffset(0)] public Span<Int32> Span; [FieldOffset(0)] public Raw Raw; } 

यहां Raw हम अपने हाथों से घोषित कर सकते हैं और पुन: उपयोग कर सकते हैं। IsByRefLikeAttribute बारे में मत भूलना। खेतों के साथ, सब कुछ सरल है:

 var spanField = typeBuilder.DefineField("Span", typeof(Span<T>), FieldAttributes.Private); spanField.SetOffset(0); var rawField = typeBuilder.DefineField("Raw", typeof(Raw), FieldAttributes.Private); rawField.SetOffset(0); 

बस इतना ही, सबसे सरल प्रकार तैयार है। अब असेंबली मॉड्यूल को कैश करें। कस्टम प्रकार कैश्ड हैं, उदाहरण के लिए, शब्दकोश में ( T -> Generated_{nameof(T)} )। हम एक रैपर बनाते हैं जो दो प्रकार के TIn और TOut अनुसार दो प्रकार के सहायक बनाता है और स्पैन पर आवश्यक संचालन करता है। एक है लेकिन प्रतिबिंब के मामले में, स्पैन (या अन्य ref struct ) पर इसका उपयोग करना लगभग असंभव है। या मुझे कोई सरल उपाय नहीं मिला । कैसे हो सकता है?

बचाव के लिए प्रतिनिधि

परावर्तन विधि आमतौर पर कुछ इस तरह दिखती है:

  object Invoke(this MethodInfo mi, object @this, object[] otherArgs) 

वे प्रकारों के बारे में जानकारी नहीं रखते हैं, इसलिए यदि बॉक्सिंग (= पैकेजिंग) आपको स्वीकार्य है, तो कोई समस्या नहीं है।
हमारे मामले में, @this और otherArgs में एक ref struct होना चाहिए, जो मुझे नहीं मिल सका।
हालांकि, एक सरल तरीका है। आइए कल्पना करें कि एक प्रकार में गेट्टर और सेटर विधियां हैं (गुण नहीं, लेकिन मैन्युअल रूप से सरल तरीके बनाए गए हैं)।
उदाहरण के लिए:

 void Generated_Int32.SetSpan(Span<Int32> span) => this.Span = span; 

विधि के अलावा, हम एक प्रतिनिधि प्रकार (स्पष्ट रूप से कोड में) की घोषणा कर सकते हैं:

 delegate void SpanSetterDelegate<T>(Span<T> span) where T : unmanaged; 

हमें ऐसा करना होगा क्योंकि मानक कार्रवाई के लिए एक Action<Span<T>> हस्ताक्षर होना चाहिए, लेकिन स्पैन को जेनेरिक तर्कों के रूप में उपयोग नहीं किया जा सकता है। SpanSetterDelegate , हालांकि, एक बिल्कुल वैध प्रतिनिधि है।
आवश्यक प्रतिनिधियों को बनाएँ। ऐसा करने के लिए, मानक जोड़तोड़ करें:

 var mi = type.GetMethod("Method_Name"); // ,    public & instance var spanSetter = (SpanSetterDelegate<T>) mi.CreateDelegate(typeof(SpanSetterDelegate<T>), @this); 

अब spanSetter का उपयोग किया जा सकता है, उदाहरण के लिए, spanSetter(Span<T>.Empty); । @this ^{2 के रूप में} , यह हमारे गतिशील प्रकार का एक उदाहरण है, निश्चित रूप से, Activator.CreateInstance(type) माध्यम से बनाया गया है। @this Activator.CreateInstance(type) , क्योंकि संरचना में कोई तर्क के साथ डिफ़ॉल्ट निर्माता है।

तो, अंतिम सीमा - हमें विधिपूर्वक विधियाँ उत्पन्न करने की आवश्यकता है।

² आप देख सकते हैं कि यहां कुछ गलत हो रहा है - Activator.CreateInstance() एक ref struct उदाहरण Activator.CreateInstance() पैक कर रहा है। अगले भाग का अंत देखें

Reflection.Emit मिलो

मुझे लगता है कि Expression के रूप में विधियों का उत्पादन किया जा सकता है, जैसा कि हमारे तुच्छ पाने वालों के शरीर / वासियों का शाब्दिक रूप से एक-दो भाव हैं। मैंने एक अलग, अधिक प्रत्यक्ष दृष्टिकोण चुना।

यदि आप एक तुच्छ पाने वाले के IL- कोड को देखते हैं, तो आप कुछ ऐसा देख सकते हैं ( Debug , X86 , netframework4.8 )

 nop ldarg.0 ldfld /* - */ stloc.0 br.s /*  */ ldloc.0 ret 

रोकने और डीबग करने के लिए बहुत सारे स्थान हैं।
रिलीज़ संस्करण में, केवल सबसे महत्वपूर्ण अवशेष:

 ldarg.0 ldfld /* - */ ret 

उदाहरण विधि का अशक्त तर्क है ... this । इस प्रकार, निम्नलिखित IL में लिखा गया है:
1) इसे डाउनलोड this
2) फ़ील्ड मान लोड करें
3) इसे वापस लाओ

बस हुह? Reflection.Emit में एक विशेष अधिभार होता है, जो op कोड के अलावा एक फील्ड डिस्क्रिप्टर पैरामीटर भी होता है। जैसा कि हमने पहले प्राप्त किया था, उदाहरण के लिए spanField ।

 var getSpan = type.DefineMethod("GetSpan", MethodAttributes.Public | MethodAttributes.HideBySig, CallingConventions.Standard, typeof(Span<T>), Array.Empty<Type>()); gen = getSpan.GetILGenerator(); gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Ldfld, spanField); gen.Emit(OpCodes.Ret); 

सेटर के लिए, यह थोड़ा अधिक जटिल है, आपको इसे स्टैक पर लोड करने, फ़ंक्शन के पहले तर्क को लोड करने की आवश्यकता है, फिर फ़ील्ड में लेखन निर्देश को कॉल करें और कुछ भी वापस न करें:

 ldarg.0 ldarg.1 stfld /*   */ ret 

Raw क्षेत्र के लिए इस प्रक्रिया को करने के बाद, आवश्यक प्रतिनिधियों (या मानक लोगों का उपयोग करके) की घोषणा करते हुए, हमें एक गतिशील प्रकार और चार एक्सेसर विधियां मिलती हैं, जिनसे सही सामान्य प्रतिनिधि उत्पन्न होते हैं।

हम एक रैपर क्लास लिखते हैं जो दो जेनेरिक मापदंडों ( TIn , TOut ) का उपयोग करते हुए Type इंस्टेंस प्राप्त करता है जो संबंधित (कैश्ड) डायनामिक प्रकारों को संदर्भित करता है, जिसके बाद यह प्रत्येक प्रकार की एक वस्तु बनाता है और चार जेनेरिक प्रतिनिधियों को उत्पन्न करता है, अर्थात्

1. void SetSpan(Span<TIn> span) संरचना को स्रोत स्पैन लिखने के लिए
2. Raw GetRaw() संरचना के रूप में एक स्पैन की सामग्री को पढ़ने के लिए Raw GetRaw()
3. void SetRaw(Raw raw) संशोधित Raw संरचना को दूसरी वस्तु में लिखने के लिए
4. Span<TOut> GetSpan() वांछित प्रकार के स्पैन को सही ढंग से सेट और पुनर्गठित फ़ील्ड के साथ वापस करने के लिए।

दिलचस्प है, गतिशील प्रकार के उदाहरणों को एक बार बनाने की आवश्यकता होती है। एक प्रतिनिधि बनाते समय, इन वस्तुओं का एक संदर्भ @this पैरामीटर के रूप में पारित किया जाता है। यहां नियमों का उल्लंघन है। Activator.CreateInstance रिटर्न object । जाहिरा तौर पर यह इस तथ्य के कारण है कि गतिशील प्रकार ने खुद को type.IsByRef जैसा नहीं किया था ( type.IsByRef Like == false ), लेकिन यह ref -समान फ़ील्ड बनाने के लिए संभव था। जाहिर है, इस तरह का प्रतिबंध भाषा में मौजूद है, लेकिन CLR इसे पचाता है। शायद यह यहां है कि गैर-मानक उपयोग के मामले में घुटनों को गोली मार दी जाएगी। ³

तो, हमें एक सामान्य प्रकार का एक उदाहरण मिलता है जिसमें चार प्रतिनिधि और गतिशील वर्गों के उदाहरणों के दो निहित संदर्भ होते हैं। एक ही जाति को एक पंक्ति में रखते समय प्रतिनिधि और संरचनाओं का पुन: उपयोग किया जा सकता है। प्रदर्शन में सुधार करने के लिए, हम फिर से एक जोड़ी (TIn, TOut) -> Generator<TIn, TOut> लिए कैश (पहले से ही एक प्रकार का कनवर्टर (TIn, TOut) -> Generator<TIn, TOut> ।

स्ट्रोक अंतिम है: हम प्रकार देते हैं, Span<TIn> -> Span<TOut>

 public Span<TOut> Cast(Span<TIn> span) { //      if (span.IsEmpty) return Span<TOut>.Empty; // Caller   ,       if (span.Length * Unsafe.SizeOf<TIn>() % Unsafe.SizeOf<TOut>() != 0) throw new InvalidOperationException(); //      // Span<TIn> _input.Span = span; _spanSetter(span); //  Raw // Raw raw = _input.Raw; var raw = _rawGetter(); var newRaw = new Raw() { Pinnable = raw.Pinnable, //    Pinnable Pointer = raw.Pointer, //   Length = raw.Length * Unsafe.SizeOf<TIn>() / Unsafe.SizeOf<TOut>() //   }; //   Raw    // Raw _output.Raw = newRaw; _rawSetter(newRaw); //     // Span<TOut> _output.Span return _spanGetter(); } 

निष्कर्ष

कभी-कभी खेल के हित के लिए - आप भाषा की कुछ सीमाओं को दरकिनार कर सकते हैं और गैर-मानक कार्यक्षमता को लागू कर सकते हैं। बेशक, अपने जोखिम और जोखिम पर। यह ध्यान देने योग्य है कि गतिशील विधि आपको पॉइंटर्स और unsafe / fixed संदर्भों को पूरी तरह से त्यागने की अनुमति देती है, जो एक बोनस हो सकता है। स्पष्ट नकारात्मक पक्ष प्रतिबिंब और प्रकार की पीढ़ी की आवश्यकता है।

उन लोगों के लिए जो अंत तक पढ़े हैं।

 BenchmarkDotNet=v0.11.5, OS=Windows 10.0.18362 Intel Core i7-2700K CPU 3.50GHz (Sandy Bridge), 1 CPU, 8 logical and 4 physical cores [Host] : .NET Framework 4.7.2 (CLR 4.0.30319.42000), 32bit LegacyJIT-v4.8.3815.0 Clr : .NET Framework 4.7.2 (CLR 4.0.30319.42000), 32bit LegacyJIT-v4.8.3815.0 Job=Clr Runtime=Clr InvocationCount=1 UnrollFactor=1 

पुनश्च

 static Raw Generated_Int32.GetRaw(Span<int> span) { var inst = new Generated_Int32() { Span = span }; return inst.Raw; } 

 static Span<int> Generated_Int32.GetSpan(Raw raw); 

 delegate Raw GetRaw<T>(Span<T> span) where T : unmanaged; delegate Span<T> GetSpan<T>(Raw raw) where T : unmanaged; 

 var getter = type.GetMethod(@"GetRaw", BindingFlags.Static | BindingFlags.Public).CreateDelegate(typeof(GetRaw<T>), null) as GetRaw<T>; 

 Raw raw = getter(Span<TIn>.Empty); Raw newRaw = convert(raw); Span<TOut> = setter(newRaw); 

UPD01: