C # प्रतिनिधि का वास्तविक विश्व उपयोग [बंद]


16

मुझे लगता है कि मैं अवधारणात्मक रूप से सी # प्रतिनिधियों को समझता हूं, हालांकि, मैं एक वास्तविक दुनिया उदाहरण खोजने के लिए संघर्ष कर रहा हूं जहां वे उपयोगी होंगे। क्या आप इस बात का विवरण दे सकते हैं कि वास्तविक अनुप्रयोगों में C # प्रतिनिधियों का किस प्रकार उपयोग किया गया और उन्होंने आपको किन समस्याओं के लिए सक्षम किया।


2
.NET फ्रेमवर्क में लगभग हर एक वर्ग घटनाओं के कुछ सेट को उजागर करता है, इसलिए आप वहां जाते हैं। यह काम की किसी इकाई को कूटबद्ध करने का एक तरीका है। उदाहरण के लिए, मान लें कि आप सी। में एक सामान्य बाइनरी ट्री संरचना को लागू कर रहे थे। ठीक है, आपके पेड़ को ऑर्डर करने का एकमात्र तरीका एक पैरामीटर पॉइंटर पॉइंटर के रूप में लेना होगा जो जानता था कि छंटाई कैसे करना है।
एड एस।

जवाबों:


16

GUI कोड ईवेंट्स को हैंडल करने के लिए डेलिगेट्स का उपयोग करता है, जैसे बटन क्लिक, विंडो मूव्स। प्रतिनिधि का उपयोग करने से आपको जब भी घटना होती है, तब एक फ़ंक्शन होता है। एक उदाहरण एक फ़ंक्शन को लिंक करना होगा जो डेटा को इंटरफ़ेस पर "सहेजें" बटन से बचाता है। जब बटन पर क्लिक किया जाता है तो यह उस फ़ंक्शन को निष्पादित करने के लिए सेट किया जाता है जो डेटा बचाता है। यह GUI प्रोग्रामिंग में उपयोगी है क्योंकि आपका पूरा कार्यक्रम उपयोगकर्ता को कुछ करने के लिए इंतजार कर सकता है और आपके पास यह जानने का कोई तरीका नहीं है कि वे पहले क्या करेंगे। प्रतिनिधियों का उपयोग करने से आपके प्रोग्राम की कार्यक्षमता यूआई से इस तरह से जुड़ी हो सकती है कि उपयोगकर्ता किसी भी तरह से अपनी इच्छानुसार काम कर सकता है।


2
++ आप सही हैं, लेकिन मैं अभी भी इसे नफरत करता हूं :-) इसलिए सदियों पहले मैं इसके बजाय आया था
माइक डनलवे

12

Linq मापदंडों के रूप में सभी जगह का उपयोग करता है Func<T>और Action<T>प्रतिनिधि करता है ।

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


12

वस्तुतः ऑब्जर्वर पैटर्न का उपयोग करने वाले कुछ भी प्रतिनिधियों को लागू करेंगे।

विवरण पढ़ें और आप शायद कुछ परिदृश्यों की कल्पना करेंगे जहां आप उनका उपयोग करेंगे। GUI ईवेंट हैंडलिंग एक सामान्य उदाहरण है।


+1, रणनीति का पैटर्न वास्तव में है जहां प्रतिनिधि चमकते हैं, यानी, आपके पास कुछ वर्ग है जहां कुछ विधि कुछ करती है, लेकिन आप चाहते हैं कि कुछ विनिमेय हो और प्रत्यक्ष निर्भरता के बिना, प्रतिनिधियों को हटा दें। ध्यान दें कि थोड़े थोड़े समय के लिए ईवेंट की ज़रूरतों को पूरा करते हैं, अंतर यह है कि आप प्रतिनिधियों का उपयोग तब करते हैं जब आपको कुछ रिटर्न वैल्यू पर प्रतिक्रिया करने की आवश्यकता होती है, जबकि आप सिर्फ फायर इवेंट और जो कुछ भी होगा।
होमडे फादर 28'11

9

प्रतिनिधि अतुल्यकालिक प्रोग्रामिंग में खूनी उपयोगी हैं।

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


9

डेलिगेट्स विशेष रूप से मध्य पैटर्न के छेद के समाधान के रूप में उपयोगी होते हैं । अनिवार्य रूप से, ऐसे कई मामले हैं जहां आप निर्देशों के एक सामान्य समूह के अंदर निर्देशों का एक अनूठा सेट लपेटना चाहते हैं। यह विशेष रूप से मुश्किल है, अगर पहले और बाद के निर्देशों को राज्य को साझा करने की आवश्यकता है। प्रतिनिधियों के साथ, आप केवल एक प्रतिनिधि को एक समारोह में पारित कर सकते हैं। फ़ंक्शन पहले बिट को निष्पादित करता है, प्रतिनिधि को निष्पादित करता है, फिर बिट के बाद निष्पादित करता है।


5

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

विंडोिंग सिस्टम में, सभी प्रकार के कॉलबैक एक ही पैटर्न का पालन करते हैं।

लिस्प में, शुरुआती दिनों में भी, एक "कार्यात्मक तर्क" या FUNARG नामक कुछ था, जो न केवल एक फ़ंक्शन था, बल्कि इसमें एक भंडारण संदर्भ भी शामिल था जहां यह बाहरी दुनिया के हिस्से के साथ याद और बातचीत कर सकता था।

OOP भाषाओं में भी यही आवश्यकता होती है, सिवाय जब आप किसी फ़ंक्शन के पते को पास करते हैं, तो आपको उस फ़ंक्शन का पता भी पास करना होगा जो फ़ंक्शन का एक तरीका है। यही दो चीजें आपको पास करनी होंगी। तो एक प्रतिनिधि सिर्फ इतना है, और उस पुराने पैटर्न को अभी भी उपयोग करने की अनुमति देता है।


3

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

Action<Button, Action<Button>> prepareButton = 
    (btn, nxt) => { 
        btn.Height = 32;
        btn.Width= 64;
        nxt(btn);
    };

prepareButton(myBtn1, btn => btn.Text = "A");
prepareButton(myBtn2, btn => btn.Text = "B");
prepareButton(myBtn3, btn => btn.Text = "C");

यहाँ उस लाभ का एक वास्तविक विश्व उदाहरण है जो प्रतिनिधि प्रदान करते हैं।

protected override void PageInitialize()
{
    const string selectCodeFormat = "javascript:selectCode('{0}', '{1}');";
    const string onClick = "return toggleElement(this);";

    Func<HtmlGenericControl> getElement = null;
    Action<HtmlGenericControl> setElement = null, addChild = null;
    HtmlGenericControl level1Element = null, level2Element = null, level3Element = null, level4Element = null;
    string className = null, code = null, description = null;           

    using (var records = Core.Database.ExecuteRecords("code.SocCodeTree"))
    {
        while (records.Read())
        {
            code = records.GetString("Code");
            description = records.GetString("Description"); 

            if (records.GetString("Level4") != "")
            {
                className = "Level4";
                setElement = e => level4Element = e;
                getElement = () => level4Element;
                addChild = e => level3Element.Controls.Add(e);
            }
            else if (records.GetString("Level3") != "")
            {
                className = "Level3";
                setElement = e => level3Element = e;
                getElement = () => level3Element;
                addChild = e => level2Element.Controls.Add(e);
            }
            else if (records.GetString("Level2") != "")
            {
                className = "Level2";
                setElement = e => level2Element = e;
                getElement = () => level2Element;
                addChild = e => level1Element.Controls.Add(e);
            }
            else
            {
                className = "Level1";
                setElement = e => level1Element = e;
                getElement = () => level1Element;
                addChild = e => Root.Controls.Add(e);
            }

            var child = new HtmlGenericControl("li");
            child.Attributes["class"] = className;
            var span = new HtmlGenericControl("span") { 
                InnerText = code + " - " + description + " - " 
            };
            span.Attributes["onclick"] = onClick;
            child.Controls.Add(span);
            var a = new HtmlAnchor() { 
                InnerText = "Select", 
                HRef = string.Format(selectCodeFormat, code, description) 
            };
            child.Controls.Add(a);
            setElement(new HtmlGenericControl("ul"));
            child.Controls.Add(getElement());
            addChild(child);    
        }
    }
}

2

प्रतिनिधियों के साथ मेरी पहली मुठभेड़ मेरी वेबसाइट से एक फ़ाइल डाउनलोड करके एक प्रोग्राम अपडेट (विंडोज़ फॉर्म सी # 3.5) के लिए जाँच कर रही थी, लेकिन पूरे प्रोग्राम को लॉक करने वाले अपडेट की जाँच से बचने के लिए मैंने एक प्रतिनिधि और एक सूत्र का उपयोग करते हुए इसे अतुल्यकालिक रूप से किया।


1

मैंने रणनीति पैटर्न का दिलचस्प कार्यान्वयन देखा है जो प्रतिनिधियों को प्रभावी ढंग से उपयोग करता है। (यानी रणनीति एक प्रतिनिधि है)

जिस पर मैं देख रहा था वह पाथफाइंडिंग के लिए था जहाँ पथ खोजने के लिए एल्गोरिथ्म एक प्रतिनिधि था जिसे रनटाइम के लिए (पुनः) सौंपा जा सकता था ताकि विभिन्न एल्गोरिदम का उपयोग किया जा सके (बीएफएस बनाम ए * आदि)।


1

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

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.