डिस्पोजेबल पैटर्न (डिस्पोजेबल डिजाइन सिद्धांत) पीटी। 2

सेफहैंडल / क्रिटिकलहैंडल / सेफबफ़र / व्युत्पन्न प्रकार

मुझे लगता है कि मैं आपके लिए भानुमती का पिटारा खोलने जा रहा हूं। चलो विशेष प्रकारों के बारे में बात करते हैं: सेफहैंडल, क्रिटिकलहैंडल और उनके व्युत्पन्न प्रकार।

यह एक प्रकार के पैटर्न के बारे में अंतिम बात है जो अप्रबंधित संसाधन तक पहुंच प्रदान करता है। लेकिन पहले, आइए उन सभी चीजों को सूचीबद्ध करें जो हम आमतौर पर अप्रबंधित दुनिया से प्राप्त करते हैं:

पहली और स्पष्ट बात हैंडल है। यह .NET डेवलपर के लिए एक अर्थहीन शब्द हो सकता है, लेकिन यह ऑपरेटिंग सिस्टम की दुनिया का एक महत्वपूर्ण घटक है। एक हैंडल प्रकृति द्वारा एक 32- या 64-बिट संख्या है। यह एक ऑपरेटिंग सिस्टम के साथ बातचीत का एक खुला सत्र नामित करता है। उदाहरण के लिए, जब आप कोई फ़ाइल खोलते हैं तो आपको WinApi फ़ंक्शन से हैंडल मिलता है। फिर आप इसके साथ काम कर सकते हैं और ऑपरेशन कर सकते हैं, पढ़ सकते हैं या लिख सकते हैं । या, आप नेटवर्क एक्सेस के लिए एक सॉकेट खोल सकते हैं। फिर से एक ऑपरेटिंग सिस्टम आपको एक हैंडल देगा। .NET हैंडल में IntPtr प्रकार के रूप में संग्रहीत किया जाता है;

यह अध्याय रूसी से संयुक्त रूप से लेखक द्वारा और पेशेवर अनुवादकों द्वारा अनुवादित किया गया था । आप रूसी या अंग्रेजी से किसी अन्य भाषा में अनुवाद करने में हमारी मदद कर सकते हैं, मुख्यतः चीनी या जर्मन में।

इसके अलावा, यदि आप हमें धन्यवाद देना चाहते हैं, तो आप सबसे अच्छा तरीका यह कर सकते हैं कि हमें गितुब पर एक स्टार देना है या रिपॉजिटरी को फोर्क करना है github / sidristij / dotnetbook ।

• दूसरी बात डेटा सरणियाँ है। आप असुरक्षित कोड (असुरक्षित यहां एक प्रमुख शब्द है) के माध्यम से या तो अप्रबंधित सरणियों के साथ काम कर सकते हैं या SafeBuffer का उपयोग कर सकते हैं जो डेटा बफर को एक उपयुक्त .NET क्लास में लपेट देगा। ध्यान दें कि पहला तरीका तेज़ है (उदाहरण के लिए, आप लूप को बहुत अनुकूलित कर सकते हैं), लेकिन दूसरा बहुत सुरक्षित है, क्योंकि यह सेफहैंडल पर आधारित है;
• फिर तार जाते हैं। स्ट्रिंग्स सरल हैं क्योंकि हमें स्ट्रिंग के प्रारूप और एन्कोडिंग को निर्धारित करने की आवश्यकता है। यह तब हमारे लिए कॉपी किया जाता है (एक स्ट्रिंग एक अपरिवर्तनीय वर्ग है) और हम इसके बारे में चिंता नहीं करते हैं।
• आखिरी चीज है ValueTypes जो सिर्फ इसलिए कॉपी की जाती हैं कि हमें उनके बारे में सोचने की जरूरत नहीं है।

सेफहैंडल एक विशेष .NET सीएलआर क्लास है जो क्रिटिकल फ़ाइनलाइज़रऑबजेक्ट को इनहेरिट करता है और एक ऑपरेटिंग सिस्टम के हैंडल को सबसे सुरक्षित और सबसे आरामदायक तरीके से लपेटना चाहिए।

[SecurityCritical, SecurityPermission(SecurityAction.InheritanceDemand, UnmanagedCode=true)] public abstract class SafeHandle : CriticalFinalizerObject, IDisposable { protected IntPtr handle; // The handle from OS private int _state; // State (validity, the reference counter) private bool _ownsHandle; // The flag for the possibility to release the handle. // It may happen that we wrap somebody else's handle // have no right to release. private bool _fullyInitialized; // The initialized instance [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)] protected SafeHandle(IntPtr invalidHandleValue, bool ownsHandle) { } // The finalizer calls Dispose(false) with a pattern [SecuritySafeCritical] ~SafeHandle() { Dispose(false); } // You can set a handle manually or automatically with p/invoke Marshal [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] protected void SetHandle(IntPtr handle) { this.handle = handle; } // This method is necessary to work with IntPtr directly. It is used to // determine if a handle was created by comparing it with one of the previously // determined known values. Pay attention that this method is dangerous because: // // – if a handle is marked as invalid by SetHandleasInvalid, DangerousGetHandle // it will anyway return the original value of the handle. // – you can reuse the returned handle at any place. This can at least // mean, that it will stop work without a feedback. In the worst case if // IntPtr is passed directly to another place, it can go to an unsafe code and become // a vector for application attack by resource substitution in one IntPtr [ResourceExposure(ResourceScope.None), ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] public IntPtr DangerousGetHandle() { return handle; } // The resource is closed (no more available for work) public bool IsClosed { [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] get { return (_state & 1) == 1; } } // The resource is not available for work. You can override the property by changing the logic. public abstract bool IsInvalid { [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] get; } // Closing the resource through Close() pattern [SecurityCritical, ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] public void Close() { Dispose(true); } // Closing the resource through Dispose() pattern [SecuritySafeCritical, ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] public void Dispose() { Dispose(true); } [SecurityCritical, ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] protected virtual void Dispose(bool disposing) { // ... } // You should call this method every time when you understand that a handle is not operational anymore. // If you don't do it, you can get a leak. [SecurityCritical, ResourceExposure(ResourceScope.None)] [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] [MethodImplAttribute(MethodImplOptions.InternalCall)] public extern void SetHandleAsInvalid(); // Override this method to point how to release // the resource. You should code carefully, as you cannot // call uncompiled methods, create new objects or produce exceptions from it. // A returned value shows if the resource was releases successfully. // If a returned value = false, SafeHandleCriticalFailure will occur // that will enter a breakpoint if SafeHandleCriticalFailure // Managed Debugger Assistant is activated. [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] protected abstract bool ReleaseHandle(); // Working with the reference counter. To be explained further. [SecurityCritical, ResourceExposure(ResourceScope.None)] [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)] [MethodImplAttribute(MethodImplOptions.InternalCall)] public extern void DangerousAddRef(ref bool success); public extern void DangerousRelease(); } 

सेफ़हैंडल से ली गई कक्षाओं की उपयोगिता को समझने के लिए आपको यह याद रखना होगा कि .NET प्रकार इतने महान क्यों हैं: GC अपने उदाहरणों को स्वचालित रूप से एकत्र कर सकते हैं। जैसे ही सेफहैंडल का प्रबंधन किया जाता है, यह बिना लपेटे हुए संसाधन को प्रबंधित दुनिया की सभी विशेषताओं से विरासत में मिलता है। इसमें बाहरी संदर्भों का एक आंतरिक काउंटर भी होता है जो सीएलआर के लिए अनुपलब्ध हैं। मेरा मतलब असुरक्षित कोड से है। आपको किसी काउंटर को मैन्युअल रूप से बढ़ाने या घटाने की आवश्यकता नहीं है। जब आप सुरक्षित विधि से एक असुरक्षित विधि के एक पैरामीटर के रूप में व्युत्पन्न एक प्रकार की घोषणा करते हैं, तो उस पद्धति में प्रवेश करते समय काउंटर वृद्धि होती है या बाहर निकलने के बाद घट जाती है। कारण यह है कि जब आप एक हैंडल को पास करके एक असुरक्षित कोड पर जाते हैं, तो आप GC द्वारा एकत्रित किए गए इस SafeHandle को दूसरे धागे में इस हैंडल के संदर्भ को रीसेट करके (यदि आप कई थ्रेड्स में से एक हैंडल से निपटते हैं) प्राप्त कर सकते हैं। एक संदर्भ काउंटर के साथ चीजें और भी आसान काम करती हैं: सेफहैंडल तब तक नहीं बनाया जाएगा जब तक काउंटर शून्य न हो जाए। इसलिए आपको मैन्युअल रूप से काउंटर बदलने की आवश्यकता नहीं है। या, आपको इसे बहुत सावधानी से वापस करना चाहिए जब संभव हो।

एक संदर्भ काउंटर का दूसरा उद्देश्य CriticalFinalizerObject फ़ाइनलाइज़रऑबजेक्ट को अंतिम रूप देने का क्रम निर्धारित करना है जो एक दूसरे को संदर्भित करता है। यदि एक SafeHandle- आधारित प्रकार दूसरे को संदर्भित करता है, तो आपको इसके अलावा संदर्भित प्रकार के निर्माता में एक संदर्भ काउंटर बढ़ाना होगा और रिलीज़हैंडल विधि में काउंटर को कम करना होगा। इस प्रकार, आपकी वस्तु तब तक मौजूद रहेगी जब तक कि आपके ऑब्जेक्ट के संदर्भ नष्ट नहीं हो जाते। हालांकि, ऐसी पहेलियों से बचना बेहतर है। आइए सेफहैंडलर के बारे में ज्ञान का उपयोग करें और हमारी कक्षा का अंतिम संस्करण लिखें:

 public class FileWrapper : IDisposable { SafeFileHandle _handle; bool _disposed; public FileWrapper(string name) { _handle = CreateFile(name, 0, 0, 0, 0, 0, IntPtr.Zero); } public void Dispose() { if(_disposed) return; _disposed = true; _handle.Dispose(); } [MethodImpl(MethodImplOptions.AggressiveInlining)] private void CheckDisposed() { if(_disposed) { throw new ObjectDisposedException(); } } [DllImport("kernel32.dll", EntryPoint = "CreateFile", SetLastError = true)] private static extern SafeFileHandle CreateFile(String lpFileName, UInt32 dwDesiredAccess, UInt32 dwShareMode, IntPtr lpSecurityAttributes, UInt32 dwCreationDisposition, UInt32 dwFlagsAndAttributes, IntPtr hTemplateFile); /// other methods } 

यह अलग कैसे है? यदि आप DllImport मेथड में किसी भी SafeHandle- आधारित प्रकार (अपने सहित) को रिटर्न वैल्यू के रूप में सेट करते हैं, तो मार्शल इस प्रकार को सही ढंग से बनाएगा और इनिशियलाइज़ करेगा और एक काउंटर सेट करेगा। 1. यह जानते हुए कि हम SafeFileHportle प्रकार को रिटर्न टाइप के लिए सेट करते हैं। CreateFile कर्नेल फ़ंक्शन। जब हम इसे प्राप्त करते हैं, तो हम रीडाइल और राइटफाइल को कॉल करने के लिए इसका सटीक उपयोग करेंगे (कॉल करते समय काउंटर वैल्यू वृद्धि के रूप में और इसे बाहर निकलते समय यह सुनिश्चित करेंगे कि हैंडल अभी भी फाइल से पढ़ने और लिखने के दौरान मौजूद है)। यह एक सही ढंग से डिज़ाइन किया गया प्रकार है और यह एक थ्रेड के गर्भपात होने पर मज़बूती से फ़ाइल हैंडल को बंद कर देगा। इसका मतलब है कि हमें अपने स्वयं के फाइनल और इसके साथ जुड़ी हर चीज को लागू करने की आवश्यकता नहीं है। पूरे प्रकार का सरलीकरण किया गया है।

एक अंतिम निष्पादन जब उदाहरण के तरीके काम करते हैं

कचरा संग्रह के दौरान उपयोग की जाने वाली एक अनुकूलन तकनीक है जिसे कम समय में अधिक वस्तुओं को इकट्ठा करने के लिए डिज़ाइन किया गया है। आइए निम्नलिखित कोड देखें:

 public void SampleMethod() { var obj = new object(); obj.ToString(); // ... // If GC runs at this point, it may collect obj // as it is not used anymore // ... Console.ReadLine(); } 

एक ओर, कोड सुरक्षित दिखता है, और यह स्पष्ट नहीं है कि हमें क्यों परवाह करनी चाहिए। हालांकि, यदि आपको याद है कि ऐसी कक्षाएं हैं जो अप्रबंधित संसाधनों को लपेटती हैं, तो आप समझेंगे कि गलत तरीके से डिज़ाइन किया गया वर्ग अप्रबंधित दुनिया से अपवाद का कारण हो सकता है। यह अपवाद रिपोर्ट करेगा कि पहले प्राप्त हैंडल सक्रिय नहीं है:

 // The example of an absolutely incorrect implementation void Main() { var inst = new SampleClass(); inst.ReadData(); // inst is not used further } public sealed class SampleClass : CriticalFinalizerObject, IDisposable { private IntPtr _handle; public SampleClass() { _handle = CreateFile("test.txt", 0, 0, IntPtr.Zero, 0, 0, IntPtr.Zero); } public void Dispose() { if (_handle != IntPtr.Zero) { CloseHandle(_handle); _handle = IntPtr.Zero; } } ~SampleClass() { Console.WriteLine("Finalizing instance."); Dispose(); } public unsafe void ReadData() { Console.WriteLine("Calling GC.Collect..."); // I redirected it to the local variable not to // use this after GC.Collect(); var handle = _handle; // The imitation of full GC.Collect GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect(); Console.WriteLine("Finished doing something."); var overlapped = new NativeOverlapped(); // it is not important what we do ReadFileEx(handle, new byte[] { }, 0, ref overlapped, (a, b, c) => {;}); } [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)] static extern IntPtr CreateFile(String lpFileName, int dwDesiredAccess, int dwShareMode, IntPtr securityAttrs, int dwCreationDisposition, int dwFlagsAndAttributes, IntPtr hTemplateFile); [DllImport("kernel32.dll", SetLastError = true)] static extern bool ReadFileEx(IntPtr hFile, [Out] byte[] lpBuffer, uint nNumberOfBytesToRead, [In] ref NativeOverlapped lpOverlapped, IOCompletionCallback lpCompletionRoutine); [DllImport("kernel32.dll", SetLastError = true)] static extern bool CloseHandle(IntPtr hObject); } 

मानते हैं कि यह कोड कम या ज्यादा सभ्य दिखता है। वैसे भी, ऐसा नहीं लगता कि कोई समस्या है। वास्तव में, एक गंभीर समस्या है। एक क्लास फाइनलर इसे पढ़ते हुए एक फ़ाइल को बंद करने का प्रयास कर सकता है, जो लगभग अनिवार्य रूप से एक त्रुटि की ओर जाता है। क्योंकि इस मामले में त्रुटि स्पष्ट रूप से वापस आ गई है ( IntPtr == -1 ) हम इसे नहीं देखेंगे। _handle को शून्य पर सेट किया जाएगा, निम्न Dispose फ़ाइल को बंद करने में विफल हो जाएगा और संसाधन लीक हो जाएगा। इस समस्या को हल करने के लिए, आपको SafeHandle , CriticalHandle , SafeBuffer और उनके व्युत्पन्न वर्गों का उपयोग करना चाहिए। इसके अलावा कि इन वर्गों के पास अप्रबंधित कोड में उपयोग के काउंटर हैं, इन काउंटरों को भी स्वचालित रूप से वृद्धि होती है जब अप्रबंधित दुनिया के तरीकों के मापदंडों के साथ गुजरते हैं और इसे छोड़ने पर गिरावट होती है।

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

इसके अलावा, यदि आप "धन्यवाद" कहना चाहते हैं, तो सबसे अच्छा तरीका जो आप चुन सकते हैं, वह हमें जीथब या रिपॉजिटरी पर एक स्टार दे रहा है। https://github.com/sidristij/dotnetbook