C # 8.0 में डिस्पोजेबल रेफरी संरचना

आइए देखते हैं कि C # 8.0 में इस आगामी बदलाव के बारे में ब्लॉग क्या कहता है (विजुअल स्टूडियो 2019 पूर्वावलोकन 2 संस्करण):

“स्टैक-ओनली स्ट्रक्चर सी # 7.2 में दिखाई दिया। वे बेहद उपयोगी हैं, लेकिन साथ ही उनका उपयोग प्रतिबंधों से निकटता से संबंधित है, उदाहरण के लिए, इंटरफेस को लागू करने में असमर्थता। अब आईडी संरचनाओं का उपयोग किए बिना लिंक संरचनाओं को उनके अंदर डिस्पोज़ विधि का उपयोग करके साफ किया जा सकता है। "

तो यह है: स्टैक-ओनली रिफ स्ट्रक्चर इंटरफेस को लागू नहीं करते हैं, अन्यथा उनकी पैकेजिंग की संभावना उत्पन्न होती है। इसलिए, वे आईडीसोपायरी को लागू नहीं कर सकते, और हम इन संरचनाओं का उपयोग कथन में नहीं कर सकते हैं:

class Program { static void Main(string[] args) { using (var book = new Book()) { Console.WriteLine("Hello World!"); } } } ref struct Book : IDisposable { public void Dispose() { } } 

इस कोड को चलाने का प्रयास करने से संकलन त्रुटि हो जाएगी :

 Error CS8343 'Book': ref structs cannot implement interfaces 

हालाँकि, अब यदि हम संदर्भ संरचना में सार्वजनिक Dispose विधि जोड़ते हैं, तो using कथन जादुई रूप से इसे स्वीकार करेगा और सब कुछ संकलित करेगा:

 class Program { static void Main(string[] args) { using (var book = new Book()) { // ... } } } ref struct Book { public void Dispose() { } } 

इसके अलावा, बयान में बदलाव के लिए धन्यवाद, अब आप छोटे रूप में (तथाकथित घोषणाओं using ) उपयोग कर सकते हैं:

 class Program { static void Main(string[] args) { using var book = new Book(); // ... } } 

लेकिन ... क्यों?

यह एक लंबी कहानी है, लेकिन समग्र रूप से स्पष्ट सफाई (निर्धारक अंतिमकरण) निहित सफाई (गैर-निर्धारक अंतिमकरण) के लिए बेहतर है। यह सहज है। यह स्पष्ट है कि जितनी जल्दी हो सके संसाधनों को साफ करना (क्लोज़, कॉल, डिस्पोज़ या स्टेटमेंट का उपयोग करके), इसके बजाय निहित सफाई का इंतजार करना होगा जो किसी दिन होगा (जब पर्यावरण खुद ही फाइनल शुरू करता है)।

इसलिए, एक प्रकार बनाते समय जो एक निश्चित संसाधन का मालिक होता है, यह स्पष्ट रूप से सफाई की संभावना के लिए प्रदान करना बेहतर होता है। C # में, यह स्पष्ट रूप से IDisposable इंटरफ़ेस और इसकी Dispose विधि है।

नोट। यह मत भूलो कि संदर्भ संरचनाओं के मामले में, केवल स्पष्ट सफाई का उपयोग किया जाता है, क्योंकि फाइनल की परिभाषा उनके लिए असंभव है।

आइए एक सामान्य उदाहरण "अप्रतिबंधित मेमोरी पूल के लिए आवरण" का एक उदाहरण देखें। यह सबसे छोटी संभव जगह घेरता है (ढेर का उपयोग बिल्कुल नहीं किया जाता है) लिंक संरचना के लिए सटीक रूप से धन्यवाद, जो लोगों के लिए उपयुक्त है:

 public unsafe ref struct UnmanagedArray<T> where T : unmanaged { private T* data; public UnmanagedArray(int length) { data = // get memory from some pool } public ref T this[int index] { get { return ref data[index]; } } public void Dispose() { // return memory to the pool } } 

चूंकि आवरण में एक अप्रबंधित संसाधन होता है, इसलिए हम उपयोग के बाद इसे साफ करने के लिए डिस्पोज़ विधि का उपयोग करते हैं। तो उदाहरण कुछ इस तरह है:

 static void Main(string[] args) { var array = new UnmanagedArray<int>(10); Console.WriteLine(array[0]); array.Dispose(); } 

यह असुविधाजनक है क्योंकि आपको कॉलिंग डिस्पोज के बारे में याद रखने की आवश्यकता है। इसके अलावा, यह एक दर्दनाक निर्णय है, क्योंकि अपवादों को ठीक से संभालना यहां लागू नहीं है। इसलिए, डिस्पोज़ को भीतर से बुलाए जाने के लिए, कथन का उपयोग किया गया था। हालांकि, पहले, जैसा कि पहले ही उल्लेख किया गया है, इस स्थिति में इसे लागू करना असंभव था।

लेकिन C # 8.0 में, आप स्टेटमेंट स्टेटमेंट का पूरा फायदा उठा सकते हैं:

 static void Main(string[] args) { using (var array = new UnmanagedArray<int>(10)) { Console.WriteLine(array[0]); } } 

इसी समय, घोषणाओं के लिए कोड अधिक संक्षिप्त हो गया है:

 static void Main(string[] args) { using var array = new UnmanagedArray<int>(10); Console.WriteLine(array[0]); } 

नीचे दिए गए अन्य दो उदाहरण (संक्षिप्तता के लिए छोड़े गए कोड के बहुत) CoreFX रिपॉजिटरी से लिए गए हैं।

पहला उदाहरण ValueUtf8Converter संदर्भ संरचना है, जो एक सरणी पूल से बाइट [] सरणी लपेटता है:

 internal ref struct ValueUtf8Converter { private byte[] _arrayToReturnToPool; ... public ValueUtf8Converter(Span<byte> initialBuffer) { _arrayToReturnToPool = null; } public Span<byte> ConvertAndTerminateString(ReadOnlySpan<char> value) { ... } public void Dispose() { byte[] toReturn = _arrayToReturnToPool; if (toReturn != null) { _arrayToReturnToPool = null; ArrayPool<byte>.Shared.Return(toReturn); } } } 

दूसरा उदाहरण RegexWriter है, जो दो ValueListBuilder संदर्भ संरचनाओं को लपेटता है जिन्हें स्पष्ट रूप से साफ़ करने की आवश्यकता है (क्योंकि वे सरणी पूल से सरणियों का प्रबंधन करते हैं):

 internal ref struct RegexWriter { ... private ValueListBuilder<int> _emitted; private ValueListBuilder<int> _intStack; ... public void Dispose() { _emitted.Dispose(); _intStack.Dispose(); } } 

निष्कर्ष

हटाने योग्य संदर्भित संरचनाओं को निम्न-स्थान प्रकारों के रूप में सोचा जा सकता है जिनके पास वास्तविक विनाशकारी है, जैसा कि C ++ में है। जैसे ही संबंधित उदाहरण का उपयोग करने वाले बयान के दायरे (या उपयोग करने की घोषणा के मामले में गुंजाइश) से परे इसे लागू किया जाएगा।

बेशक, नियमित, व्यावसायिक-उन्मुख कार्यक्रम लिखते समय वे अचानक लोकप्रिय नहीं होंगे, लेकिन यदि आप उच्च-प्रदर्शन, निम्न-स्तरीय कोड बना रहे हैं, तो आपको उनके बारे में पता होना चाहिए।

और हमारे पास हमारे सम्मेलन के बारे में एक लेख भी है: