क्या सी # 4 "गतिशील कास्टिंग" की अनुमति देगा? यदि नहीं, तो सी # इसका समर्थन करना चाहिए?

Question

मेरा मतलब यह नहीं है कि एक कम व्युत्पन्न वर्ग में निचला इंटरफ़ेस या बेस क्लास कास्टिंग करने के अर्थ में गतिशील कास्टिंग का मतलब है, मेरा मतलब है कि मैंने एक इंटरफ़ेस परिभाषा ले ली है जिसे मैंने बनाया है, और फिर गतिशील रूप से उस इंटरफेस को कास्टिंग करने के लिए एक अलग ऑब्जेक्ट नहीं लिया गया है उस इंटरफेस से लेकिन सभी कॉल का समर्थन करते हैं।

उदाहरणों गतिशील के साथ घोषित के लिए उदाहरण के लिए

,

interface IMyInterface 
{ 
    bool Visible 
    { 
     get; 
    } 
} 

TextBox myTextBox = new TextBox(); 
IMyInterface i = (dynamic<IMyInterface>)myTextBox; 

यह जाना जाता है प्रकार के लिए संकलन समय पर प्राप्त किया जा सकता है, और क्रम। इंटरफ़ेस परिभाषा ज्ञात है, जैसा कि प्रकार (इस उदाहरण में) है, इसलिए संकलक यह निर्धारित कर सकता है कि ऑब्जेक्ट इंटरफ़ेस द्वारा परिभाषित कॉल का समर्थन करता है और हमारे लिए कास्ट रखने के लिए कुछ जादू करता है।

मेरा अनुमान है कि यह सी # 4 में समर्थित नहीं है (मैं इसका संदर्भ नहीं ढूंढ पाया), लेकिन मैं निश्चित रूप से जानना चाहता हूं। और यदि यह नहीं है, तो मैं चर्चा करना चाहता हूं कि इसे भाषा के भविष्य के संस्करण में शामिल किया जाना चाहिए या नहीं, और इसके कारण और इसके विपरीत। मेरे लिए, यह मौजूदा ढांचे प्रकारों को लपेटने के लिए पूरे नए प्रकार बनाने के बिना कोड में अधिक बहुलकता को सक्षम करने के लिए एक अच्छा जोड़ा लगता है।

अद्यतन
ऐसा न हो कि कोई मुझे साहित्यिक चोरी का आरोप, मैं Jon Skeet having already proposed this के बारे में पता नहीं था। हालांकि, यह जानकर अच्छा लगा कि हमने अत्यधिक समान वाक्यविन्यास के बारे में सोचा, जो बताता है कि यह कम से कम सहज हो सकता है। इस बीच, "एक मूल विचार है" एक और दिन के लिए मेरी बाल्टी सूची पर बना हुआ है।

Answer 1

मुझे लगता है कि जॉन स्कीट के पास ऐसा प्रस्ताव था (http://msmvps.com/blogs/jon_skeet/archive/2008/10/30/c-4-0-dynamic-lt-t-gt.aspx), लेकिन अब तक, मैंने नहीं सुना है कि सी # 4.0 के पास यह होगा।

Answer 2

मुझे लगता है कि यह समस्याग्रस्त है। आप दो वर्गों के बीच युग्मन शुरू कर रहे हैं जो युग्मित नहीं हैं।

निम्नलिखित कोड पर विचार करें।

public interface IFoo 
{ 
    int MethodA(); 
    int MethodB(); 
} 

public class Bar 
{ 
    int MethodA(); 
    int MethodB(); 
} 

public class SomeClass 
{ 
    int MethodFoo(IFoo someFoo); 
} 

क्या यह कानूनी होना चाहिए?

int blah = someClass.MethodFoo((dynamic<IFoo>)bar); 

यह लगता है जैसे कि यह कानूनी होना चाहिए, क्योंकि संकलक गतिशील कुछ है कि IFoo लागू करता है के रूप में बार टाइप करने के लिए सक्षम होना चाहिए।

हालांकि, इस बिंदु पर आप IFoo और बार एक फोन के माध्यम से अपने कोड की एक पूरी तरह से अलग हिस्से में युग्मन कर रहे हैं।

आप बार संपादित करते हैं क्योंकि यह अब MethodB की जरूरत है, अचानक someClass.MethodFood अब और काम नहीं करता है, भले ही बार और IFoo संबंधित नहीं हैं।

उसी तरह, अगर आप IFoo को MethodC() जोड़ने के लिए, अपने कोड फिर से टूट जाएगा, भले ही IFoo और बार जाहिरा तौर पर संबंधित नहीं हैं।

तथ्य यह है कि, यह उन चुनिंदा मामलों में उपयोगी होगा जहां ऐसी वस्तुओं के समानताएं हैं जिन्हें आप नियंत्रित नहीं करते हैं, एक कारण है कि इंटरफेस को वस्तुओं से स्पष्ट रूप से संलग्न किया जाना चाहिए, और कारण यह है कि संकलक गारंटी ले सकते हैं कि वस्तु यह लागू करता है।

Answer 3

सी # के लिए कोई ज़रूरत नहीं के रूप में यह बहुत सफाई से पुस्तकालय के रूप में लागू किया जा सकता है, इस का समर्थन करने के लिए है।

मैंने तीन या चार अलग-अलग कार्यान्वयन देखा है (मैंने उन्हें ढूंढने से पहले खुद को लिखना शुरू कर दिया था)।

http://bartdesmet.net/blogs/bart/archive/2008/11/10/introducing-the-c-ducktaper-bridging-the-dynamic-world-with-the-static-world.aspx

यह शायद भी एक बार डीएलआर क्रम में एकीकृत है लागू करने के लिए आसान हो जाएगा: यहाँ सबसे व्यापक उपचार मैंने देखा है है।

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

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

वे अभी भी सी # 4.0 (भिन्नता विशेषताओं) में अच्छी चीजें कर रहे हैं लेकिन संकलन समय पर समस्याओं का पता लगाने के लिए टाइप सिस्टम को बेहतर, अधिक स्वचालित, अधिक शक्तिशाली बनाने के लिए और भी बहुत कुछ किया जा सकता है। इसके बजाए, हम अनिवार्य रूप से एक चीज प्राप्त कर रहे हैं।

Answer 4

ओपनसोर्स फ्रेमवर्क Impromptu-Interface यह सी # 4 और डीएलआर का उपयोग करता है।

using ImpromptuInterface; 

interface IMyInterface 
{ 
    bool Visible 
    { 
     get; 
    } 
} 

TextBox myTextBox = new TextBox(); 
IMyInterface i = myTextBox.ActLike<IMyInterface>(); 

यह भी ExpandoObject और DynamicObject के साथ काम करेंगे चूंकि यह डीएलआर उपयोग करता है।