🧔🏿 👩🏻‍🏫 🌦️ जेनेरिक की कला 👩🏽‍🤝‍👩🏼 🏟️ 🧒🏼

यूनिवर्सल टेम्प्लेट - वे भी जेनरिक हैं, सबसे शक्तिशाली विकास उपकरण में से एक हैं।

सीएलआर एमएसआईएल स्तर और संपूर्ण रनटाइम पर उनका समर्थन करता है, जो हमें कुछ प्रकार के सुरक्षा चालें करने की अनुमति देता है।

यदि आप C ++ टेम्प्लेट से परिचित हैं, लेकिन इसे क्रैंक करना चाहते हैं, यदि संकलन चरण में संकलन नहीं है, तो अनुग्रह से किसी भी तरह से C # ऑपरेशन से हीन नहीं हैं, तो यह लेख इस में मदद करेगा।

पैटर्न के बारे में थोड़ा सा

कोड के अधिक सुविधाजनक संगठन के लिए, साथ ही प्रोग्रामिंग पैटर्न के विकास में ओओपी का उपयोग आमतौर पर संयोजन में किया जाता है।

[ नोट: नीचे दिए गए उदाहरण विशेष रूप से जेनेरिक के साथ "ट्रिक्स" से संबंधित नहीं हैं, जो कि लेख का मुख्य उद्देश्य है। लेखक सिर्फ विचार की ट्रेन दिखाना चाहता है ।]

MVC के लायक क्या है। जहां, नियंत्रक पक्ष पर तर्क प्रसंस्करण के लिए, आप एक रणनीति का उपयोग कर सकते हैं, बल्कि कारखाने विधि के साथ (एक सार कारखाने के साथ भ्रमित नहीं होने के लिए)।

उनका वर्णन करना GoF से बेहतर है, तो चलिए आगे बढ़ते हैं।

इस तरह के पैटर्न हैं:

बहु प्रेषण
दोहरा प्रेषण (यह एक प्रकार का विज़िटर पैटर्न भी है)

पहले का सार एकल प्रेषण का विस्तार करना है - यह ऑब्जेक्ट के प्रकार से ओवरलोड करता है।

उदाहरण के लिए, C # 4 और इसके डायनेमिक से शुरू करके आप आसानी से विकिपीडिया से एक उदाहरण दिखा सकते हैं।

मुलतान प्रेषण

class Program { class Thing { } class Asteroid : Thing { } class Spaceship : Thing { } static void CollideWithImpl(Asteroid x, Asteroid y) { Console.WriteLine("Asteroid collides with Asteroid"); } static void CollideWithImpl(Asteroid x, Spaceship y) { Console.WriteLine("Asteroid collides with Spaceship"); } static void CollideWithImpl(Spaceship x, Asteroid y) { Console.WriteLine("Spaceship collides with Asteroid"); } static void CollideWithImpl(Spaceship x, Spaceship y) { Console.WriteLine("Spaceship collides with Spaceship"); } static void CollideWith(Thing x, Thing y) { dynamic a = x; dynamic b = y; CollideWithImpl(a, b); } static void Main(string[] args) { var asteroid = new Asteroid(); var spaceship = new Spaceship(); CollideWith(asteroid, spaceship); CollideWith(spaceship, spaceship); } }

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

दोहरा प्रेषण

 class Program { interface ICollidable { void CollideWith(ICollidable other); } class Asteroid : ICollidable { public void CollideWith(Asteroid other) { Console.WriteLine("Asteroid collides with Asteroid"); } public void CollideWith(Spaceship spaceship) { Console.WriteLine("Asteroid collides with Spaceship"); } public void CollideWith(ICollidable other) { other.CollideWith(this); } } class Spaceship : ICollidable { public void CollideWith(ICollidable other) { other.CollideWith(this); } public void CollideWith(Asteroid asteroid) { Console.WriteLine("Spaceship collides with Asteroid"); } public void CollideWith(Spaceship spaceship) { Console.WriteLine("Spaceship collides with Spaceship"); } } static void Main(string[] args) { var asteroid = new Asteroid(); var spaceship = new Spaceship(); asteroid.CollideWith(spaceship); asteroid.CollideWith(asteroid); } }

ठीक है, जैसा कि आप देख सकते हैं, आप गतिशील के बिना कर सकते हैं।

तो यह सब क्यों?

इसका उत्तर सरल है - यदि हम एकल प्रेषण का विस्तार कर सकते हैं, जो कि ऑब्जेक्ट के प्रकार से ओवरलोडिंग है, कई ऑब्जेक्ट्स ( कई डिस्पैच ) पर ओवरलोडिंग के मामले में आगे बढ़ रहा है, तो जेनरिक के साथ भी ऐसा क्यों नहीं किया जाता है?!

। कोवरियनस && कंट्रावेरियन

सामान्य तौर पर, किसी भी प्रोग्रामिंग भाषा में कोवरियन टाइप करने के लिए दी गई लगती है। उदाहरण के लिए:

 var asteroid = new Asteroid(); ICollidable collidable = asteroid;

हालाँकि, इसे असाइनमेंट संगतता कहा जाता है।

जेनरिक के साथ काम करने पर कोवरियन सटीक रूप से प्रकट होता है।

 List<Asteroid> asteroids = new List<Asteroid>(); IEnumerable<ICollidable> collidables = asteroids;

IEnumerable घोषणा निम्नानुसार है:

 public interface IEnumerable<out T> : IEnumerable { IEnumerator<T> GetEnumerator(); }

आउट कीवर्ड और सहसंयोजक समर्थन के अभाव में, सूची <T> वर्ग इस इंटरफ़ेस को लागू करने के बावजूद, सूची <क्षुद्रग्रह> प्रकार को IEnumerable <ICollidable> टाइप करना असंभव होगा।

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

 interface ICustomInterface<out T> { T Do(T target); //compile-time error T Do(IList<T> targets); //compile-time error }

ठीक है, आइए इस सुविधा को ध्यान दें, लेकिन अभी के लिए, आइए अपने लक्ष्य की ओर बढ़ें - हम जेनरिक के साथ ओवरलोडिंग की संभावना का विस्तार करेंगे।

▌ जेनरिक संकलन-समय की जाँच

निम्नलिखित इंटरफ़ेस पर विचार करें:

 public interface IReader<T> { T Read(T[] arr, int index); }

पहली नज़र में कुछ भी असामान्य नहीं है। हालांकि, केवल संख्याओं या फ़्लोटिंग पॉइंट संख्याओं के लिए कार्यान्वयन कैसे लागू किया जाए? यानी संकलन समय पर प्रतिबंध लागू करें?

C # ऐसा अवसर प्रदान नहीं करता है। आप इसे केवल एक टाइप्ड पैरामीटर के लिए एक संरचना, वर्ग, या एक विशिष्ट प्रकार (वहाँ अभी भी नया () है) के रूप में नामित कर सकते हैं।

 public interface IReader<T> where T : class { T Read(T[] arr, int index); }

कई प्रेषण के लिए क्षुद्रग्रह उदाहरण याद है?

IReader के कार्यान्वयन के लिए हम इसका उपयोग करेंगे।

 public class SignedIntegersReader : IReader<Int32>, IReader<Int16>, IReader<Int64> { int IReader<int>.Read(int[] arr, int index) { return arr[index]; } short IReader<short>.Read(short[] arr, int index) { return arr[index]; } long IReader<long>.Read(long[] arr, int index) { return arr[index]; } }

मुझे लगता है कि सवाल उठता है - इंटरफ़ेस का स्पष्ट कार्यान्वयन क्यों?

यह किसी भी इंटरफ़ेस विधि के लिए सहसंयोजक का समर्थन करने के बारे में है।

इसलिए, सहसंयोजक इंटरफेस में विधियों में टाइप टी के साथ पैरामीटर नहीं हो सकते हैं, यहां तक कि, उदाहरण के लिए, IList।

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

खैर, यह व्यवहार में इन अवसरों का उपयोग करने के लिए रहता है।

 public static class ReaderExtensions { public static T Read<TReader, T>(this TReader reader, T[] arr, int index) where TReader : IReader<T> { return reader.Read(arr, index); } } class Program { static void Main(string[] args) { var reader = new SignedIntegersReader(); var arr = new int[] {128, 256}; for (int i = 0; i < arr.Length; i++) { Console.WriteLine("Reader result: {0}", reader.Read(arr, i)); } } }

चलिए फ्लोट [] के चर चर के प्रकार को बदलने का प्रयास करते हैं।

 class Program { static void Main(string[] args) { var reader = new SignedIntegersReader(); var arr = new float[] {128.0f, 256.0f}; for (int i = 0; i < arr.Length; i++) { Console.WriteLine("Reader result: {0}", reader.Read(arr, i)); //compile-time error } } }

लेकिन क्या यह केवल विस्तार विधियों के माध्यम से प्राप्त किया गया है?! क्या होगा यदि इंटरफ़ेस कार्यान्वयन आवश्यक है?

हम अपने IReader इंटरफ़ेस को थोड़ा संशोधित करेंगे।

IReader <टी>

 public interface IReader<T> { T Read(T[] arr, int index); bool Supports<TType>(); } public class SignedIntegersReader : IReader<Int32>, IReader<Int16>, IReader<Int64> { int IReader<int>.Read(int[] arr, int index) { return arr[index]; } short IReader<short>.Read(short[] arr, int index) { return arr[index]; } long IReader<long>.Read(long[] arr, int index) { return arr[index]; } public bool Supports<TType>() { return this as IReader<TType> != null; } }

और IReader का एक और कार्यान्वयन जोड़ें - DefaultReader।

 public class DefaultReader<T> : IReader<T> { private IReader<T> _reader = new SignedIntegersReader() as IReader<T>; public T Read(T[] arr, int index) { if (_reader != null) { return _reader.Read(arr, index); } return default(T); } public bool Supports<TType>() { return _reader.Supports<TType>(); } }

व्यवहार में जाँच करें:

 class Program { static void Main(string[] args) { var reader = new DefaultReader<int>(); var arr = new int[] { 128, 256 }; if (reader.Supports<int>()) { for (int i = 0; i < arr.Length; i++) { Console.WriteLine("Reader result: {0}", reader.Read(arr, i)); } } } }

इस प्रकार, हमें मानकीकृत प्रकारों द्वारा ओवरलोड की जाँच के कार्य के दो कार्यान्वयन मिले - संकलन और निष्पादन दोनों के दौरान।

जेनेरिक की कला

पैटर्न के बारे में थोड़ा सा

। कोवरियनस && कंट्रावेरियन

▌ जेनरिक संकलन-समय की जाँच

More articles: