दिलचस्प पोस्ट
एक स्ट्रिंग के दूसरे स्ट्रिंग के साथ बदलें क्या होगा अगर मैं एक अहस्ताक्षरित चर के लिए एक नकारात्मक मान निर्दिष्ट करता हूँ? संदर्भित DLL को लोड करने के लिए कौन से स्थान खोजे गए हैं? {"<user xmlns = ''> उम्मीद नहीं की गई थी।) ट्विटर एक्सपेराइलिंग करना तो, JSONP या CORS? डीआईवी के आयाम को कैसे पता लगाया जाए? चयन क्यों * हानिकारक माना जाता है? सी #: चलाने की प्रक्रिया का पूरा रास्ता कैसे प्राप्त करें? मैं नए PostgreSQL JSON डेटाटाइप के अंदर फ़ील्ड का प्रयोग कैसे करूं? Preg_replace () और preg_replace_callback के साथ संशोधक बदलें जेडीबीसी में एक कनेक्शन पूल कैसे स्थापित करें? ObservableCollection AddRange विधि का समर्थन नहीं करता है, इसलिए मुझे प्रत्येक आइटम के लिए अधिसूचित किया गया, इसके अलावा INotifyCollectionChanging के बारे में क्या? jQuery के .load () IE में काम नहीं कर रहा है – लेकिन फ़ायरफ़ॉक्स, क्रोम और सफारी में ठीक है एक बहुभाषी डेटाबेस के लिए स्कीमा उपयोगकर्ता के साथ कोनेर 2 गतिशील टैब चयनित घटक क्लिक करें

सी # एकाधिक विरासत है चाहिए?

मुझे सी # पर बहुमूल्य विरासत को शामिल करने के विरुद्ध कई तर्क मिल गए हैं, जिनमें से कुछ में (दार्शनिक तर्कों को एक तरफ) शामिल हैं:

  • एकाधिक विरासत बहुत जटिल है और अक्सर अस्पष्ट है
  • यह अनावश्यक है क्योंकि इंटरफेस कुछ समान प्रदान करते हैं
  • संरचना एक अच्छा विकल्प है जहां इंटरफेस अनुचित हैं

मैं एक सी + + पृष्ठभूमि से आया हूँ और कई वंशानुक्रमों की शक्ति और सुंदरता को याद नहीं करता। यद्यपि यह सभी सॉफ्टवेयर डिज़ाइनों के लिए अनुकूल नहीं है, वहां ऐसी स्थितियां हैं जहां इंटरफेस, संरचना और इसी तरह की ओ ओ तकनीकों पर इसकी उपयोगिता से इनकार करना मुश्किल है।

क्या कई वंशानुक्रमों का बहिष्कार कह रहा है कि डेवलपर्स उन्हें बुद्धिमानी से उपयोग करने के लिए पर्याप्त स्मार्ट नहीं हैं और जब वे उठता है तो जटिलताओं को संबोधित करने में असमर्थ हैं?

मैं व्यक्तिगत रूप से कई विरासत की शुरुआत सी # में (शायद सी # #) में स्वागत करेंगे


परिशिष्ट : मुझे उन प्रतिक्रियाओं से जानने में दिलचस्पी होगी जो एक एकल (या प्रक्रियात्मक पृष्ठभूमि) से एक बहु विरासत पृष्ठभूमि बनाम से आता है। मैंने अक्सर पाया है कि ऐसे डेवलपर्स जिनके पास बहु-विरासत का कोई अनुभव नहीं है, अक्सर बहु-विरासत-अनावश्यक तर्क के लिए डिफ़ॉल्ट होगा क्योंकि उनके पास प्रतिमान के साथ कोई अनुभव नहीं है

वेब के समाधान से एकत्रित समाधान "सी # एकाधिक विरासत है चाहिए?"

मैं कभी इसे कभी नहीं याद किया, कभी नहीं हां, यह [एमआई] जटिल हो जाता है, और हाँ, इंटरफेस कई तरह से एक समान काम करते हैं – लेकिन यह सबसे बड़ा मुद्दा नहीं है: सामान्य अर्थ में, यह बस अधिकांश समय की आवश्यकता नहीं है यहां तक ​​कि कई मामलों में एकल विरासत का उपयोग किया जाता है।

विरासत पर एकत्रीकरण को प्राथमिकता देना!

class foo : bar, baz 

अक्सर बेहतर ढंग से संभाला जाता है

 class foo : Ibarrable, Ibazzable { ... public Bar TheBar{ set } public Baz TheBaz{ set } public void BarFunction() { TheBar.doSomething(); } public Thing BazFunction( object param ) { return TheBaz.doSomethingComplex(param); } } 

इस तरह आप आईबीराबबल और आईबीजेबल के अलग-अलग कार्यान्वयन और ऐप को स्वैप कर सकते हैं ताकि एक और क्लास को लिखने के बिना ऐप के कई संस्करण तैयार किए जा सकें।

निर्भरता इंजेक्शन इस बहुत मदद कर सकता है।

एकाधिक विरासत से निपटने के मुद्दों में से एक इंटरफ़ेस विरासत और कार्यान्वयन वंशानुक्रम के बीच भेद है।

सी # पहले से ही शुद्ध इंटरफेस का उपयोग करके इंटरफ़ेस विरासत का एक स्वच्छ कार्यान्वयन (अंतर्निहित या स्पष्ट कार्यान्वयन के विकल्प सहित) है।

अगर आप class घोषणापत्र में बृहदान्त्र के बाद निर्दिष्ट प्रत्येक वर्ग के लिए, आप जिस प्रकार की विरासत प्राप्त करते हैं, वह एक्सेस मॉडिफ़र ( private , protected , या public ) द्वारा निर्धारित होता है। public उत्तराधिकार के साथ, आप कई विरासत के पूर्ण गड़बड़ी प्राप्त करते हैं- एकाधिक इंटरफेस एकाधिक कार्यान्वयन के साथ मिश्रित होते हैं। private विरासत के साथ, आप केवल कार्यान्वयन प्राप्त करें " class Foo : private Bar " का एक ऑब्जेक्ट किसी फ़ंक्शन को पारित नहीं किया जा सकता है जो Bar अपेक्षा करता है क्योंकि ऐसा लगता है कि Foo क्लास में वास्तव में एक निजी Bar फ़ील्ड और स्वचालित रूप से लागू प्रतिनिधिमंडल पैटर्न है ।

शुद्ध एकाधिक क्रियान्वयन उत्तराधिकार (जो वास्तव में केवल स्वचालित प्रतिनिधिमंडल है) किसी भी समस्या को प्रस्तुत नहीं करता है और सी # में होने के लिए बढ़िया होगा।

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

यहाँ एक संभावना है:

 abstract class Gun { public void Shoot(object target) {} public void Shoot() {} public abstract void Reload(); public void Cock() { Console.Write("Gun cocked."); } } class Camera { public void Shoot(object subject) {} public virtual void Reload() {} public virtual void Focus() {} } //this is great for taking pictures of targets! class PhotoPistol : Gun, Camera { public override void Reload() { Console.Write("Gun reloaded."); } public override void Camera.Reload() { Console.Write("Camera reloaded."); } public override void Focus() {} } var pp = new PhotoPistol(); Gun gun = pp; Camera camera = pp; pp.Shoot(); //Gun.Shoot() pp.Reload(); //writes "Gun reloaded" camera.Reload(); //writes "Camera reloaded" pp.Cock(); //writes "Gun cocked." camera.Cock(); //error: Camera.Cock() not found ((PhotoPistol) camera).Cock(); //writes "Gun cocked." camera.Shoot(); //error: Camera.Shoot() not found ((PhotoPistol) camera).Shoot();//Gun.Shoot() pp.Shoot(target); //Gun.Shoot(target) camera.Shoot(target); //Camera.Shoot(target) 

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

इसके अलावा, आप असीमित रूपांतरण ऑपरेटर के साथ सी # आज में कई विरासत को लागू कर सकते हैं:

 public class PhotoPistol : Gun /* ,Camera */ { PhotoPistolCamera camera; public PhotoPistol() { camera = new PhotoPistolCamera(); } public void Focus() { camera.Focus(); } class PhotoPistolCamera : Camera { public override Focus() { } } public static Camera implicit operator(PhotoPistol p) { return p.camera; } } 

यह सही नहीं है, हालांकि, जैसा कि यह और ऑपरेटरों के as समर्थित नहीं is , और System.Type.IsSubClassOf()

यहां बहुविध विरासत के लिए एक बहुत ही उपयोगी मामला है जो मैं हर समय चलाता हूं।

टूलकिट विक्रेता के रूप में, मैं प्रकाशित एपीआई को बदल नहीं सकता या मैं पीछे की संगतता को तोड़ दूंगा। एक बात यह है कि इससे एक परिणाम यह है कि मैं इसे कभी भी एक इंटरफ़ेस में जोड़ नहीं सकता क्योंकि यह किसी को लागू करने के लिए संकलन को तोड़ देगा – केवल एकमात्र विकल्प इंटरफ़ेस का विस्तार करना है

यह मौजूदा ग्राहकों के लिए ठीक है, लेकिन नए लोगों को यह पदानुक्रम अनावश्यक जटिल के रूप में देखना होगा, और अगर मैं इसे शुरुआत से डिजाइन कर रहा था, तो मैं इसे इस तरह लागू करने का विकल्प नहीं देता – मुझे करना है, या फिर मैं पिछली संगतता खो दूंगा । यदि इंटरफ़ेस आंतरिक है, तो मैं इसे बस जोड़ूंगा और कार्यान्वयनकर्ताओं को ठीक कर दूंगा।

कई मामलों में, इंटरफ़ेस की नई पद्धति एक स्पष्ट और छोटे डिफ़ॉल्ट कार्यान्वयन है, लेकिन मैं इसे प्रदान नहीं कर सकता।

मैं अमूर्त वर्गों का उपयोग करना पसंद करता हूं और फिर जब मुझे एक पद्धति जोड़नी है, तो एक वास्तविक कार्यान्वयन के साथ एक वर्चुअल जोड़ें, और कभी-कभी हम ऐसा करते हैं

यह मुद्दा निश्चित रूप से है, अगर यह वर्ग संभवतः कुछ ऐसी चीज़ों में मिश्रित हो जाएगा जो पहले से ही कुछ बढ़ा रहा है – तो हमारे पास इंटरफ़ेस का उपयोग करने और विस्तार इंटरफेस के साथ सौदा करने के लिए कोई विकल्प नहीं है।

अगर हमें लगता है कि हमारे पास इस समस्या को एक बड़े पैमाने पर है, तो हम एक अमीर घटना मॉडल का विकल्प चुनते हैं – जो मुझे लगता है कि शायद सी # में सही उत्तर है, लेकिन हर समस्या को इस तरह हल नहीं किया जाता है – कभी-कभी आप एक साधारण सार्वजनिक इंटरफ़ेस , और विस्तारकों के लिए एक अमीर एक

सी # एकल विरासत, इंटरफेस और विस्तार विधियों का समर्थन करता है। उन दोनों के बीच, वे सब कुछ प्रदान करते हैं जो कि एकाधिक वंशानुक्रम प्रदान करता है, सिर दर्द के बिना, जो कि बहु से अधिक विरासत लाती है

एकाधिक विरासत सीएलआर द्वारा समर्थित किसी भी तरह से समर्थित नहीं है, इसलिए मुझे संदेह है कि इसे एक कुशल तरीके से समर्थित किया जा सकता है क्योंकि यह सी ++ (या एफिल में है, जो इसे बेहतर ढंग से दे सकता है कि भाषा विशेष रूप से डिजाइन की गई है एमआई के लिए)

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

उदाहरण के लिए, मान लें कि आप आईएलआईआईएस (टी के) को लागू करने की कोशिश कर रहे हैं। यदि आप एलआईएलआईटी (टी के) के विभिन्न कार्यान्वयनों को देखते हैं, तो वे अक्सर कुछ सटीक कोड को साझा करते हैं। यही लक्षण आते हैं। आप इसमें आम कोड के साथ एक विशेषता की घोषणा करते हैं और आप आईएलआईटी (टी के) के किसी भी कार्यान्वयन में उस आम कोड का उपयोग कर सकते हैं – भले ही कार्यान्वयन में पहले से कुछ अन्य मूल वर्ग हैं। सिंटैक्स इस तरह दिख सकता है:

 /// This trait declares default methods of IList<T> public trait DefaultListMethods<T> : IList<T> { // Methods without bodies must be implemented by another // trait or by the class public void Insert(int index, T item); public void RemoveAt(int index); public T this[int index] { get; set; } public int Count { get; } public int IndexOf(T item) { EqualityComparer<T> comparer = EqualityComparer<T>.Default; for (int i = 0; i < Count; i++) if (comparer.Equals(this[i], item)) return i; return -1; } public void Add(T item) { Insert(Count, item); } public void Clear() { // Note: the class would be allowed to override the trait // with a better implementation, or select an // implementation from a different trait. for (int i = Count - 1; i >= 0; i--) RemoveAt(i); } public bool Contains(T item) { return IndexOf(item) != -1; } public void CopyTo(T[] array, int arrayIndex) { foreach (T item in this) array[arrayIndex++] = item; } public bool IsReadOnly { get { return false; } } public bool Remove(T item) { int i = IndexOf(item); if (i == -1) return false; RemoveAt(i); return true; } System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return GetEnumerator(); } IEnumerator<T> GetEnumerator() { for (int i = 0; i < Count; i++) yield return this[i]; } } 

और आप इस तरह के गुण का उपयोग करते हैं:

 class MyList<T> : MyBaseClass, DefaultListMethods<T> { public void Insert(int index, T item) { ... } public void RemoveAt(int index) { ... } public T this[int index] { get { ... } set { ... } } public int Count { get { ... } } } 

बेशक, मैं बस यहाँ सतह scratching हूँ। अधिक पूर्ण विवरण के लिए, पेपर स्पॉटिट्स: कम्पोज़बल यूनिट्स ऑफ बिहेवियर (पीडीएफ) देखें।

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

मैं वास्तव में एक विशिष्ट कारण के लिए एकाधिक विरासत को याद करता हूँ … पैटर्न का निपटान

हर बार जब मुझे निपटान पैटर्न को लागू करने की आवश्यकता होती है, तो मैं खुद से कहता हूं: "मेरा मानना ​​है कि मैं सिर्फ उन वर्गों से प्राप्त कर सकता हूं जो कुछ आभासी ओवरराइड्स के साथ निपटान पैटर्न लागू करता है।" मैं प्रत्येक वर्ग में एक ही बॉयलर-प्लेट कोड की प्रतिलिपि बनाकर पेस्ट करता हूं जो आइडिसिबल करता है और मैं इसे नफरत करता हूं।

मैं आपके लिए कारण के लिए कई विरासत के खिलाफ बहस करेगा डेवलपर्स इसका दुरुपयोग करेंगे मैंने उपयोगिता वर्ग से विरासत में मिली हर वर्ग के साथ पर्याप्त समस्याएं देखी हैं, बस इतना है कि आप जानते हैं कि बहुत से विरासत कई स्थितियों में खराब कोड तक पहुंचने के लिए बहुत कुछ टाइप करने की आवश्यकता के बिना हर कक्षा से एक फ़ंक्शन कॉल कर सकते हैं। एक ही बात GoTo के बारे में कहा जा सकता है, जो इसके उपयोग के कारणों में से एक है, इस पर इतनी सिकोड़ी है। मुझे लगता है कि कई वंशानुगतों के पास कुछ अच्छा उपयोग हैं, जैसे गोतो, एक आदर्श दुनिया में, जहां वे दोनों ही उचित थे जब कोई भी समस्याएं नहीं थीं। हालांकि, दुनिया आदर्श नहीं है, इसलिए हमें स्वयं को खराब प्रोग्रामर की रक्षा करना चाहिए।

हाँ! हाँ! और हाँ!

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

सबसे पहले मैंने सी ++ (एमआई भारी इस्तेमाल में) में स्मार्टविन ++ किया था, तब मैंने गिया अजाक्स और आखिरकार रा-अजाक्स किया था और मैं बहुत आत्मविश्वास से कह सकता हूं कि एमआई कुछ स्थानों के लिए नियम है। उन स्थानों में से एक GUI लाइब्रेरी है …

और दावा करते हुए तर्क है कि एमआई "बहुत जटिल है" और ऐसे में ज्यादातर लोगों को भाषा युद्ध बनाने की कोशिश कर रहे हैं और जो शिविर के पास होता है "वर्तमान में एमआई नहीं है" …

जैसे कि कार्यात्मक प्रोग्रामिंग भाषाओं (जैसे लिस्प) को गैर-कार्यात्मक प्रोग्रामिंग भाषा अधिवक्ताओं द्वारा "बहुत ही जटिल" के रूप में सिखाया गया है ("गैर-लिस्पर" द्वारा) …

लोग अज्ञात से डरते हैं …

एमआई नियम!

मुझे खुशी है कि सी # में एकाधिक वंशानुक्रम नहीं है, हालांकि यह कभी-कभी सुविधाजनक भी हो सकता है मैं इसके बजाय देखना चाहता हूं कि एक इंटरफ़ेस विधि का एक डिफ़ॉल्ट कार्यान्वयन प्रदान करने की क्षमता है। अर्थात्:

 interface I { void F(); void G(); } class DefaultI : I { void F() { ... } void G() { ... } } class C : I = DefaultI { public void F() { ... } // implements IF } 

इस मामले में, ((I)new C()).F() IF() C के कार्यान्वयन को कॉल करेगा, जबकि ((I)new C()).G() DefaultI IG()

कई ऐसे मुद्दे हैं जो भाषा के डिजाइनरों को भाषा में जोड़ने से पहले काम करना होगा, लेकिन कोई भी जो बहुत मुश्किल नहीं है, और नतीजा कई जरूरतों को कवर करेगी जो कई वंशानुक्रमों को वांछनीय बनाती हैं।

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

सामान्य में एकाधिक वंशानुगत उपयोगी हो सकते हैं और कई ओओ भाषाओं इसे एक ही रास्ता या अन्य (सी ++, एफिल, सीएलओएस, पायथन …) को लागू कर सकते हैं। क्या यह आवश्यक है? नहीं। क्या यह अच्छा है? हाँ।

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


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

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

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

नहीं।

(मतदान के लिए)

डेटाफैक्स 4GL v3 + (मुझे पता है, मुझे पता है, डेटा क्या है ?) के बारे में वास्तव में अच्छा और (समय पर) उपन्यास चीजों में से एक मिश्रित विरासत के लिए इसका समर्थन था – किसी भी अन्य कक्षाओं के तरीकों को आपकी कक्षा में पुन: उपयोग किया जा सकता है; जब तक आपके क्लास ने ये विधियां इस्तेमाल की हैं, तब तक यह सिर्फ ठीक काम करती थी, और "हीरा समस्या" या अन्य बहु-विरासत "मिलते" नहीं था।

मैं सी # में ऐसा कुछ देखना चाहूंगा क्योंकि यह कुछ प्रकार के अमूर्त और contruction मुद्दों को आसान बनाने में आसान होगा

कई विरासत के बजाय, आप मिक्सिक्स का उपयोग कर सकते हैं जो एक बेहतर समाधान है।

मुझे लगता है कि यह पर्याप्त रॉय प्रदान किए बिना चीजों को उलझाएगा हम पहले से ही लोगों को बखूबी एनएटीटी कोड देखते हैं जो बहुत अधिक वृहद विरासत वाले पेड़ हैं। मैं सिर्फ अत्याचारों की कल्पना कर सकता हूं अगर लोगों को कई विरासत करने की शक्ति होती है।

मैं इनकार नहीं करूँगा कि इसकी क्षमता है, लेकिन मुझे पर्याप्त लाभ नहीं लगता है।

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

एक सहयोगी ने इस ब्लॉग को लिखा है कि सी # के साथ डायनेमिक संकलन में कई विरासत की तरह कुछ पाने के तरीके:

http://www.atalasoft.com/cs/blogs/stevehawley/archive/2008/09/29/late-binding-in-c-using-dynamic-compilation.aspx

मुझे लगता है कि इसकी सरलता वास्तव में है बस किसी अन्य जटिल प्रोग्रामिंग प्रतिमान की तरह, आप इसका दुरुपयोग कर सकते हैं और अपने आप को चोट पहुंचा सकते हैं क्या आप ऑब्जेक्ट्स का दुरुपयोग कर सकते हैं (ओह हाँ!), लेकिन इसका अर्थ यह नहीं है कि ओ ओ खुद में खराब है।

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

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

मैं एक एमआई पृष्ठभूमि से आया हूँ, और मुझे इसके द्वारा डरे हुए या जलाया नहीं गया है।

मैंने इसे यहां कई बार पोस्ट किया है लेकिन मुझे लगता है कि यह वास्तव में अच्छा है। आप नकली एमआई यहाँ कैसे सीख सकते हैं मुझे यह भी लगता है कि यह लेख इस बात पर प्रकाश डालता है कि एमआई क्यों ऐसा दर्द है, भले ही उसका इरादा नहीं था।

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

मैंने अपने आप को भी सी ++ में कई वारिस का इस्तेमाल किया है, लेकिन आपको वास्तव में यह जानना होगा कि आपको मुसीबत में नहीं होने के लिए आप क्या कर रहे हैं, खासकर यदि आपके पास दो आधार वर्ग हैं जो एक दादा-दादी को साझा करते हैं तब आप आभासी वारिस के साथ मुद्दों में मिल सकते हैं, हर कन्स्ट्रक्टर को घोषित करने के लिए आप श्रृंखला को बुलाते हैं (जो द्विआधारी पुन: उपयोग बहुत कठिन बना देता है) … यह एक गड़बड़ी हो सकती है।

इससे भी महत्वपूर्ण बात, जिस तरह से सीएलआई वर्तमान में बनाया गया है वह आसानी से एमआई से लागू किया जा रहा है। मुझे यकीन है कि यदि वे चाहें तो वे ऐसा कर सकते हैं, लेकिन मेरे पास अन्य चीजें हैं जो मैं सीएलआई में कई वारिसनों की तुलना में देखता हूं।

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

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

मैं सी + + पसंद करते हैं मैंने जावा, सी # आदि का उपयोग किया है। जैसे कि ओ ओ पर्यावरण में मेरे कार्यक्रमों को और अधिक परिष्कृत किया जाता है, मुझे लगता है कि मुझे एक से अधिक वंशानुक्रम नहीं मिल रहा है। यह मेरा व्यक्तिपरक अनुभव है

यह आश्चर्यजनक स्पेगेटी कोड के लिए बना सकता है … यह आश्चर्यजनक सुरुचिपूर्ण कोड के लिए कर सकता है।

मेरा मानना ​​है कि सी # जैसी भाषाओं को प्रोग्रामर को विकल्प देना चाहिए सिर्फ इसलिए कि यह शायद बहुत जटिल इसका मतलब यह नहीं है कि यह बहुत जटिल हो जाएगा । प्रोग्रामिंग भाषाओं को डेवलपर को ऐसे उपकरण बनाने के लिए उपकरणों के साथ प्रदान करना चाहिए जो प्रोग्रामर चाहता है।

आप उन API का उपयोग करना चुनते हैं जो एक डेवलपर पहले से ही लिखा है, आपके पास भी नहीं है

C # implicits दें और आपको कई विरासत, या उस बात के लिए किसी भी भाग को याद नहीं होगा।

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

मैं वंशानुक्रम का उपयोग करने की कोशिश नहीं करता कम मैं हर समय कर सकता हूँ

जब तक डायमंड समस्या का हल नहीं हो जाता है। और जब तक यह हल नहीं हो तब तक आप संरचना का उपयोग कर सकते हैं।

नहीं, हम इसे से दूर आए। आपको अब इसकी ज़रूरत है

यदि हम कई विरासत का परिचय देते हैं तो हम फिर से सी ++ की पुरानी डायमंड समस्या का सामना कर रहे हैं …

हालांकि जो लोग सोचते हैं कि यह अपरिहार्य है, हम अभी भी संरचना के माध्यम से कई विरासत प्रभावों को प्राप्त कर सकते हैं (एक ऑब्जेक्ट में कई ऑब्जेक्ट लिखें और सार्वजनिक विधियों का पर्दाफाश करें जो जिम्मेदारियों को ऑब्जेक्ट बनाने और रिटर्न करने के लिए जिम्मेदार हैं) …

So why bother to have multiple inheritance and make your code vulnerable to unavoidable exceptions…