डिस्पोज़ पैटर्न

"Dispose" redirects here. For the album by The Plot In You, see Dispose (album). For other uses, see Disposal (disambiguation).

ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग में, निपटान पैटर्न संसाधन प्रबंधन के लिए एक डिज़ाइन पैटर्न है। इस पैटर्न में, एक सिस्टम संसाधन एक वस्तु द्वारा आयोजित किया जाता है, और एक पारंपरिक विधि को कॉल करके जारी किया जाता है - जिसे आमतौर पर भाषा के आधार पर close, dispose, free, release कहा जाता है - जो किसी भी संसाधन को जारी करता है, जिस पर ऑब्जेक्ट होल्ड होता है। कई प्रोग्रामिंग भाषाएं सामान्य परिस्थितियों में निपटान विधि को स्पष्ट रूप से कॉल करने से बचने के लिए भाषा निर्माण की पेशकश करती हैं।

निपटान पैटर्न मुख्य रूप से उन भाषाओं में उपयोग किया जाता है जिनके रनटाइम पर्यावरण में स्वत: कचरा संग्रह होता है।

प्रेरणा

संसाधनों को वस्तुओं में लपेटना

ऑब्जेक्ट्स में रैपिंग रिसोर्सेज एनकैप्सुलेशन का ऑब्जेक्ट-ओरिएंटेड फॉर्म है, और डिस्पोजल पैटर्न को रेखांकित करता है।

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

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

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

FILE *f = fopen(filename, mode);

// Do something with f.

fclose(f);

ध्यान दें कि fclose एक FILE * पैरामीटर वाला फ़ंक्शन है। ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग में, यह फ़ाइल ऑब्जेक्ट पर एक इंस्टेंस विधि है, जैसा कि पायथन में है:

f = open(filename)

# Do something with f.

f.close()

यह बिल्कुल निपटान पैटर्न है, और पारंपरिक फ़ाइल खोलने और बंद करने से सिंटैक्स और कोड संरचना में अलग है। अन्य संसाधनों को ठीक उसी तरह प्रबंधित किया जा सकता है: एक निर्माता या कारखाने में अधिग्रहित किया जा रहा है, और एक स्पष्ट close या dispose विधि द्वारा जारी किया जा रहा है।

शीघ्र रिलीज

मौलिक समस्या जिसका समाधान संसाधनों को मुक्त करना है, वह यह है कि संसाधन महंगे हैं (उदाहरण के लिए, खुली फ़ाइलों की संख्या पर एक सीमा हो सकती है), और इस प्रकार उन्हें तुरंत जारी किया जाना चाहिए। इसके अलावा, कभी-कभी कुछ अंतिमीकरण कार्य की आवश्यकता होती है, विशेष रूप से I/O के लिए, जैसे कि फ्लशिंग बफ़र्स यह सुनिश्चित करने के लिए कि सभी डेटा वास्तव में लिखे गए हैं।

यदि कोई संसाधन असीमित या प्रभावी रूप से असीमित है, और कोई स्पष्ट अंतिमीकरण आवश्यक नहीं है, तो इसे जारी करना महत्वपूर्ण नहीं है, और वास्तव में अल्पकालिक कार्यक्रम अक्सर संसाधनों को स्पष्ट रूप से जारी नहीं करते हैं: अल्पावधि के कारण, वे संसाधनों को समाप्त करने की संभावना नहीं रखते हैं , और वे किसी भी अंतिम रूप देने के लिए रनटाइम सिस्टम या ऑपरेटिंग सिस्टम पर भरोसा करते हैं।

हालांकि, सामान्य संसाधनों में प्रबंधित किया जाना चाहिए (विशेष रूप से लंबे समय तक रहने वाले कार्यक्रमों के लिए, कार्यक्रम जो कई संसाधनों का उपयोग करते हैं, या सुरक्षा के लिए, यह सुनिश्चित करने के लिए कि डेटा लिखा गया है)। स्पष्ट निपटान का मतलब है कि संसाधन को अंतिम रूप देना और जारी करना नियतात्मक और शीघ्र है: dispose विधि तब तक पूरी नहीं होती जब तक कि ये पूरा नहीं हो जाता।

स्पष्ट निपटान की आवश्यकता का एक विकल्प संसाधन प्रबंधन को जीवन भर के लिए बाँधना है: संसाधन वस्तु निर्माण के दौरान प्राप्त किए जाते हैं, और वस्तु विनाश के दौरान जारी किए जाते हैं। इस दृष्टिकोण को संसाधन अधिग्रहण प्रारंभ है (RAII) मुहावरा के रूप में जाना जाता है, और इसका उपयोग नियतात्मक स्मृति प्रबंधन (जैसे C ++) वाली भाषाओं में किया जाता है। इस स्थिति में, ऊपर दिए गए उदाहरण में, संसाधन तब प्राप्त होता है जब फ़ाइल ऑब्जेक्ट बनाया जाता है, और जब वेरिएबल का दायरा होता है f बाहर निकल गया है, फ़ाइल ऑब्जेक्ट कि f संदर्भित करता है नष्ट हो जाता है, और इसके हिस्से के रूप में, संसाधन जारी किया जाता है।

RAII निर्धारक होने के कारण वस्तु जीवनकाल पर निर्भर करता है; हालाँकि, स्वचालित मेमोरी प्रबंधन के साथ, ऑब्जेक्ट लाइफटाइम प्रोग्रामर की चिंता का विषय नहीं है: वस्तुओं को किसी बिंदु पर नष्ट कर दिया जाता है, जब उनका उपयोग नहीं किया जाता है, लेकिन जब अमूर्त होता है। दरअसल, जीवनकाल अक्सर निर्धारक नहीं होता है, हालांकि यह हो सकता है, विशेष रूप से यदि संदर्भ गणना का उपयोग किया जाता है। दरअसल, कुछ मामलों में इस बात की कोई गारंटी नहीं है कि वस्तुओं को कभी भी अंतिम रूप दिया जाएगा: जब कार्यक्रम समाप्त हो जाता है, तो यह वस्तुओं को अंतिम रूप नहीं दे सकता है, और इसके बजाय केवल ऑपरेटिंग सिस्टम को स्मृति को पुनः प्राप्त करने दें; यदि अंतिम रूप देने की आवश्यकता है (उदाहरण के लिए, बफर फ्लश करने के लिए), डेटा हानि हो सकती है।

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

प्रारंभिक निकास

डिस्पोजल पैटर्न के साथ एक प्रमुख समस्या यह है कि यदि dispose विधि नहीं कहा जाता है, तो संसाधन लीक हो जाता है। इसका एक सामान्य कारण जल्दी वापसी या अपवाद के कारण किसी समारोह से जल्दी बाहर निकलना है।

उदाहरण के लिए:

def func(filename):
    f = open(filename)
    if a:
        return x
    f.close()
    return y

यदि फ़ंक्शन पहली वापसी पर लौटता है, तो फ़ाइल कभी बंद नहीं होती है और संसाधन लीक हो जाता है।

def func(filename):
    f = open(filename)
    g(f)  # Do something with f that may raise an exception.
    f.close()

यदि हस्तक्षेप करने वाला कोड अपवाद उठाता है, तो फ़ंक्शन जल्दी निकल जाता है और फ़ाइल कभी बंद नहीं होती है, इसलिए संसाधन लीक हो जाता है।

इन दोनों को try...finally निर्माण द्वारा नियंत्रित किया जा सकता है, जो यह सुनिश्चित करता है कि अंत में खंड हमेशा बाहर निकलने पर निष्पादित किया जाता है:

def func(filename):
    try:
        f = open(filename)
        # Do something.
    finally:
        f.close()

अधिक सामान्य रूप से:

Resource resource = getResource();
try {
    // Resource has been acquired; perform actions with the resource.
    ...
} finally {
    // Release resource, even if an exception was thrown.
    resource.dispose();
}

try...finally निर्माण उचित अपवाद सुरक्षा के लिए आवश्यक है, क्योंकि finally में ब्लॉक क्लीनअप लॉजिक के निष्पादन को सक्षम करता है चाहे कोई अपवाद फेंका गया हो या नहीं try अवरोध पैदा करना।

इस दृष्टिकोण का एक नुकसान यह है कि प्रोग्रामर को अंत में ब्लॉक में स्पष्ट रूप से क्लीनअप कोड जोड़ने की आवश्यकता होती है finally अवरोध पैदा करना। इससे कोड आकार ब्लोट हो जाता है, और ऐसा करने में विफलता कार्यक्रम में संसाधन रिसाव का कारण बनेगी।

भाषा निर्माण

निपटान पैटर्न के सुरक्षित उपयोग को कम वर्बोज़ बनाने के लिए, कोड के एक ही ब्लॉक में रखे और जारी किए गए संसाधनों के लिए कई भाषाओं में किसी प्रकार का अंतर्निहित समर्थन होता है।

सी शार्प भाषा में using कथन है जो स्वचालित रूप से किसी ऑब्जेक्ट पर Dispose विधि को कॉल करता है जो IDisposable इंटरफ़ेस लागू करता है:

using (Resource resource = GetResource())
{
    // Perform actions with the resource.
    ...
}

जो इसके बराबर है:

Resource resource = GetResource()
try 
{
    // Perform actions with the resource.
    ...
}
finally 
{
    // Resource might not been acquired, or already freed
    if (resource != null) 
        ((IDisposable)resource).Dispose(); 
}

इसी तरह, पायथन भाषा में एक with कथन है जिसका उपयोग संदर्भ प्रबंधक वस्तु के साथ समान प्रभाव के लिए किया जा सकता है। कॉन्टेक्स्ट मैनेजर प्रोटोकॉल को __enter__ और __exit__ विधियों को लागू करने की आवश्यकता होती है, जो कोड के दोहराव को रोकने के लिए स्वचालित रूप से स्टेटमेंट निर्माण द्वारा बुलाए जाते हैं, जो अन्यथा try/finally पैटर्न के साथ होते हैं।

with resource_context_manager() as resource:
    # Perform actions with the resource.
    ...
# Perform other actions where the resource is guaranteed to be deallocated.
...

जावा भाषा ने जावा संस्करण 7 में एक नया सिंटैक्स पेश किया जिसे try-साथ-संसाधन कहा जाता है। इसका उपयोग उन वस्तुओं पर किया जा सकता है जो ऑटोक्लोसेजबल इंटरफ़ेस को लागू करते हैं (जो कि विधि को परिभाषित करता है ()):

try (OutputStream x = new OutputStream(...)) {
    // Do something with x
} catch (IOException ex) {
    // Handle exception

  // The resource x is automatically closed
} // try

समस्याएं

रिटर्न और अपवादों की उपस्थिति में सही संसाधन प्रबंधन की प्रमुख समस्या से परे, और हीप-आधारित संसाधन प्रबंधन (वस्तुओं को जहां वे बनाए गए हैं, वहां से एक अलग दायरे में निपटाना), निपटान पैटर्न से जुड़ी कई और जटिलताएं हैं। इन समस्याओं को RAII द्वारा काफी हद तक टाला जाता है। हालाँकि, सामान्य सरल उपयोग में ये जटिलताएँ उत्पन्न नहीं होती हैं: एक संसाधन प्राप्त करें, इसके साथ कुछ करें, इसे स्वचालित रूप से जारी करें।

एक मौलिक समस्या यह है कि एक संसाधन का होना अब एक वर्ग अपरिवर्तनीय नहीं है (संसाधन वस्तु निर्माण से तब तक रखा जाता है जब तक इसका निपटान नहीं किया जाता है, लेकिन वस्तु अभी भी इस बिंदु पर जीवित है), इसलिए संसाधन उपलब्ध नहीं हो सकता है जब वस्तु कोशिश करती है इसका इस्तेमाल करें, उदाहरण के लिए बंद फ़ाइल से पढ़ने की कोशिश कर रहा है। इसका मतलब यह है कि संसाधन का उपयोग करने वाली वस्तु पर सभी विधियां संभावित रूप से असफल हो जाती हैं, आम तौर पर एक त्रुटि वापस करके या अपवाद उठाकर। व्यवहार में यह मामूली है, क्योंकि संसाधनों का उपयोग आमतौर पर अन्य कारणों से भी विफल हो सकता है (उदाहरण के लिए, किसी फ़ाइल के अंत को पढ़ने की कोशिश करना), इसलिए ये विधियाँ पहले से ही विफल हो सकती हैं, और संसाधन न होने से बस एक और संभावित विफलता जुड़ जाती है। इसे लागू करने का एक मानक तरीका ऑब्जेक्ट में एक बूलियन फ़ील्ड जोड़ना है, जिसे disposed कहा जाता है, जिसे dispose करके सही पर सेट किया जाता है, और एक गार्ड क्लॉज द्वारा सभी तरीकों (जो संसाधन का उपयोग करते हैं) के लिए चेक किया जाता है, एक अपवाद उठाते हुए (जैसे कि ObjectDisposedException .NET में) यदि वस्तु का निपटान किया गया है।

यह भी देखें

• ऑब्जेक्ट लाइफटाइम
• संसाधन अधिग्रहण प्रारंभ है (RAII)

अग्रिम पठन

• Microsoft Developer Network: Dispose Pattern