C # में var कीवर्ड का उपयोग

406

C # 3 में 'var' कीवर्ड के उपयोग के बारे में सहकर्मियों के साथ चर्चा करने के बाद, मैंने सोचा कि var के माध्यम से प्रकार के निष्कर्ष के उपयुक्त उपयोग पर लोगों की क्या राय थी?

उदाहरण के लिए मैंने संदिग्ध परिस्थितियों में lazily var का उपयोग किया, उदाहरण के लिए: -

foreach(var item in someList) { // ... } // Type of 'item' not clear.
var something = someObject.SomeProperty; // Type of 'something' not clear.
var something = someMethod(); // Type of 'something' not clear.

Var के अधिक वैध उपयोग इस प्रकार हैं: -

var l = new List<string>(); // Obvious what l will be.
var s = new SomeClass(); // Obvious what s will be.

दिलचस्प है LINQ एक ग्रे क्षेत्र का एक सा लगता है, जैसे: -

var results = from r in dataContext.SomeTable
              select r; // Not *entirely clear* what results will be here.

यह स्पष्ट है कि इसमें क्या परिणाम होंगे यह एक प्रकार होगा जो IEnumerable को लागू करता है, हालांकि यह उसी तरह पूरी तरह से स्पष्ट नहीं है जिस तरह से एक नई वस्तु की घोषणा करने वाला एक संस्करण है।

यह तब और भी बुरा होता है जब यह LINQ ऑब्जेक्ट्स के लिए आता है, जैसे: -

var results = from item in someList
              where item != 3
              select item;

यह समतुल्य फॉर्च्यूनर (someList में var आइटम) से बेहतर नहीं है।

यहां टाइप सुरक्षा के बारे में एक वास्तविक चिंता है - उदाहरण के लिए अगर हम उस क्वेरी के परिणामों को एक अधिभार विधि में रखना चाहते थे जो IEnumerable <int> और IEnumerable <double> को स्वीकार करता है तो कॉलर अनजाने में गलत प्रकार से गुजर सकता है।

var मजबूत टाइपिंग को बनाए रखता है, लेकिन सवाल यह है कि क्या यह वास्तव में परिभाषा पर स्पष्ट रूप से स्पष्ट नहीं होने के लिए खतरनाक है, ऐसा कुछ जो अतिभारित है जब ओवरलोड का मतलब है कि कंपाइलर त्रुटियां तब जारी नहीं की जा सकती हैं जब आप अनजाने में गलत तरीके से एक विधि से गुजरते हैं।

c# type-inference var

— एलजे
स्रोत

68

Var का उपयोग करना ठीक है, लेकिन "मुझे टाइप करने की ज़रूरत नहीं है" ऐसा लगता है कि इसका उपयोग करने के लिए एक बहुत बुरा कारण है ... आपको यह पता होना चाहिए कि टाइप क्या है, इसे टाइप करने से बचने के लिए var सिर्फ एक शॉर्टकट है

— थॉमस लेवेस्क

53

var i = 0;== विफल! var c = new CrazyFrigginLongClassName();== जीत!

— डॉटजेओ

6

"वर मुझे वीबी / वीबीए प्रकार के प्रकार की भी याद दिलाता है। इसकी जगह भी थी। मुझे याद है (कई साल पहले) इसका उपयोग कम-से-वांछनीय प्रकार का था और यह संसाधन की भूख थी।" <- दिखाता है कि यह एक चुनौतीपूर्ण प्रश्न है क्योंकि C # के 'var' प्रकार का VB / VBA प्रकार के साथ कोई लेना-देना नहीं है।

— user7116

20

var readabilityBeDamned = true;

— ९'१०

9

यहां बताए गए सभी उदाहरणों के साथ समस्या यह है कि हम कोड की एक पंक्ति को देख रहे हैं। जब मैं "var" घोषणाओं की लाइन के बाद लाइन देखता हूं, तो एक के बाद एक, यह हाथ से निकल जाता है। पठनीयता व्यक्तिपरक है, लेकिन मुझे लगता है कि वर्जन का उपयोग सम्मानजनक तरीके से कहीं अधिक किया जाता है।

— जू जू 13:11

293

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

var orders = cust.Orders;

मुझे परवाह नहीं है अगर Customer.Orders है IEnumerable<Order>, ObservableCollection<Order>या BindingList<Order>- मैं चाहता हूं कि उस सूची को उस पर पुनरावृति करने या बाद में उसकी गिनती या कुछ पाने के लिए स्मृति में रखना है।

इसके साथ उपरोक्त घोषणा का विरोध करें:

ObservableCollection<Order> orders = cust.Orders;

मेरे लिए, टाइप नाम सिर्फ शोर है। और अगर मैं वापस जाने के लिए और ट्रैक नीचे Customer.Orders के प्रकार को बदलने का फैसला (से कहते हैं कि ObservableCollection<Order>करने के लिए IList<Order>) तो मुझे लगता है कि घोषणा भी बदलने की जरूरत है - कुछ मैं अगर मैं पहले में प्रयुक्त वर चाहते करने की जरूरत नहीं होगी जगह।

— मैट हैमिल्टन
स्रोत

48

जब मैं कोड पढ़ रहा होता हूं, तो मेरे सामने स्पष्ट प्रकार होना पसंद है। मुझे कैसे पता चलेगा कि "cust.Orders" किस प्रकार के बिना है? हां, मैं अपने माउस का पता लगाने के लिए होवर कर सकता हूं, लेकिन मुझे ऐसा क्यों करना चाहिए? :)

— जॉन टैकबरी

77

लेकिन बात यह है कि सामान्य तौर पर यह कोई मायने नहीं रखता है। बशर्ते कस्टडी.ऑर्डर्स एक ऐसी चीज है जिसे आप एनुमरेट कर सकते हैं (जैसे कि आगे की तरफ) तो यह मायने नहीं रखता कि यह किस प्रकार की है। अतिरिक्त कोड सिर्फ इरादे को पढ़ने के तरीके में मिलता है।

— मैट हैमिल्टन

67

लेकिन अगर आपको केवल उस कस्टर्ड की आवश्यकता होती है। आदेश "कुछ ऐसा है जिसे आप गणना कर सकते हैं" तो इसे IEnumerable <ऑर्डर> के रूप में घोषित नहीं किया जाता है जो उस आवश्यकता को स्पष्ट और स्पष्ट बना देता है? इसे var के रूप में घोषित करने का मतलब है कि आप उस आवश्यकता को प्रभावी रूप से खो देते हैं।

— ग्राहम

5

@jon और IEnumerbal के ऑर्डर कैसे = cust.Orders फॉरेक्स (ऑर्डर में var ऑर्डर) से फर्क पड़ेगा? IEnumerable का कहना है कि केवल एक चीज यह है कि आप इसे एक आड़ू में रख सकते हैं, लेकिन आप पहले से ही जानते थे कि नीचे दी गई पंक्ति से

— Rune FS

18

"केवल एक चीज जो IEnumerable कहती है, वह है कि आप इसे फ़र्क में डाल सकते हैं" - यह इस आशय को भी व्यक्त करता है कि केवल एक चीज जो आप कर सकते हैं वह है। Var का उपयोग करना ठोस संग्रह प्रकार के सार्वजनिक सदस्यों के लिए और इंटेलीसेन्स तक पहुंच प्रदान करता है।

— जो

167

मैं varबड़े पैमाने पर उपयोग करता हूं । आलोचना की गई है कि यह कोड की पठनीयता को कम करता है, लेकिन उस दावे का समर्थन करने के लिए कोई तर्क नहीं है।

बेशक, इसका मतलब यह हो सकता है कि यह स्पष्ट नहीं है कि हम किस प्रकार का व्यवहार कर रहे हैं। तो क्या? यह वास्तव में एक विघटित डिजाइन का बिंदु है। इंटरफेस के साथ काम करते समय, आप सशक्त रूप से उस प्रकार में रुचि नहीं रखते हैं जिस प्रकार एक चर में है। varइसे बहुत आगे ले जाता है, सच है, लेकिन मुझे लगता है कि तर्क एक पठनीयता से समान रहता है: प्रोग्रामर को वास्तव में चर के प्रकार में दिलचस्पी नहीं लेनी चाहिए, बल्कि एक चर में होता है । यही कारण है कि Microsoft भी प्रकार का अनुमान "बतख टाइपिंग" कहता है।

तो, जब मैं इसका उपयोग करने की घोषणा करता हूं तो एक चर क्या करता है var? आसान है, यह जो कुछ भी IntelliSense मुझे बताता है वह करता है। C # के बारे में कोई भी तर्क जो IDE को अनदेखा करता है, वास्तविकता से कम पड़ता है। व्यवहार में, प्रत्येक C # कोड एक IDE में प्रोग्राम किया जाता है जो IntelliSense का समर्थन करता है।

यदि मैं एक varघोषित चर का उपयोग कर रहा हूं और भ्रमित हो रहा हूं कि चर क्या है, तो मेरे कोड के साथ मौलिक रूप से कुछ गलत है। varकारण नहीं है, यह केवल लक्षण दिखाई देता है। दूत को दोष मत दो।

अब, C # टीम ने एक कोडिंग दिशानिर्देश जारी किया है जिसमें कहा गया है कि इसका उपयोग केवल एक LINQ स्टेटमेंट के परिणाम को पकड़ने के लिए किया varजाना चाहिए जो एक अनाम प्रकार बनाता है (क्योंकि यहाँ, हमारे पास कोई वास्तविक विकल्प नहीं है )। खैर, पेंच है कि। जब तक C # टीम मुझे इस दिशानिर्देश के लिए एक ध्वनि तर्क नहीं देती है, मैं इसे अनदेखा करने जा रहा हूं क्योंकि मेरी पेशेवर और व्यक्तिगत राय में, यह शुद्ध बालन है। (क्षमा करें; मुझे प्रश्न में दिशानिर्देश के लिए कोई लिंक नहीं मिला है।)var

वास्तव में, कुछ (सतही) अच्छे स्पष्टीकरण हैं कि आप का उपयोग क्यों नहीं करना चाहिए, varलेकिन मुझे अभी भी विश्वास है कि वे काफी हद तक गलत हैं। "Searchabililty" का उदाहरण लें: लेखक का दावा है कि varयह उन स्थानों के लिए खोज करना कठिन बनाता है जहां MyTypeइसका उपयोग किया जाता है। सही। इसलिए इंटरफेस करें। वास्तव में, मैं यह क्यों जानना चाहूंगा कि कक्षा का उपयोग कहां किया जाता है? मुझे इसमें अधिक रुचि हो सकती है जहां यह त्वरित है और यह अभी भी खोजा जा सकता है क्योंकि कहीं न कहीं इसके निर्माता को आमंत्रित किया जाना है (भले ही यह अप्रत्यक्ष रूप से किया जाता है, टाइप नाम कहीं उल्लेख किया जाना है)।

— कोनराड रुडोल्फ
स्रोत

14

किसी भी सभ्य आईडीई में, आप कक्षा उपयोग प्राप्त करने के लिए एक पाठ खोज का उपयोग नहीं करते हैं, आपको आईडीई यह पेड़ के आधार पर करने के लिए मिलता है या फिर यह वस्तुओं के प्रकार की पहचान करता है। चूँकि हम स्थैतिक टाइपिंग के बारे में बात कर रहे हैं, यह सब कुछ मिलेगा लेकिन गुमनाम प्रकार।

— डस्टमैन

6

मुझे कोई दस्तावेज़ और var के उदार उपयोग के साथ स्रोत की 100k लाइनों के वारिस से नफरत होगी। खासकर अगर आप कम-से-मददगार चर नामों के साथ संस्करण को जोड़ते हैं। मैं इसे एक बिंदु का चित्रण करते समय (या अनाम प्रकार से निपटने में) सहायक होने पर, उत्पादन कोड में सहायक होते हुए देख सकता था?

— शिया

7

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

— कोनराड रुडोल्फ

17

Var के विपरीत हर उदाहरण मैंने देखा है कि प्रोग्रामर अर्थहीन चर नामों का उपयोग करेगा। लेकिन शायद यही वजह है कि var एक प्रकार को स्पष्ट रूप से निर्दिष्ट करने से बेहतर है: यह प्रोग्रामर को अच्छे चर नामों के साथ आने के लिए मजबूर करता है।

— रयान लुंडी

16

Microsoft भी प्रकार का अनुमान "बतख टाइपिंग" कहता है। - क्या वे वास्तव में हैं? मैं चौंक गया हूँ ...

— एंटोन टायकी

118

वर, मेरी राय में, C # में एक अच्छी बात है ^tm । टाइप किया गया कोई भी चर अभी भी दृढ़ता से टाइप किया गया है, लेकिन यह असाइनमेंट के दाईं ओर से इसका प्रकार प्राप्त करता है जहां इसे परिभाषित किया गया है। क्योंकि टाइप जानकारी राइट-हैंड साइड पर उपलब्ध है, ज्यादातर मामलों में, यह अनावश्यक है और पीढ़ी-दर-पीढ़ी वर्बोज़ को भी बाएं-हाथ में दर्ज करना पड़ता है। मुझे लगता है कि इस प्रकार की सुरक्षा में कमी के बिना यह पठनीयता बढ़ाता है।

मेरे दृष्टिकोण से, चर और विधियों के लिए अच्छे नामकरण सम्मेलनों का उपयोग करना स्पष्ट प्रकार की जानकारी की तुलना में पठनीयता के दृष्टिकोण से अधिक महत्वपूर्ण है। यदि मुझे टाइप जानकारी की आवश्यकता है, तो मैं हमेशा चर (वीएस) पर होवर कर सकता हूं और प्राप्त कर सकता हूं। आम तौर पर, हालांकि, स्पष्ट प्रकार की जानकारी पाठक के लिए आवश्यक नहीं होनी चाहिए। डेवलपर के लिए, वीएस में आपको अभी भी इंटैलिजेंस मिलता है, भले ही चर घोषित कैसे हो। उस सब के बाद भी, ऐसे मामले हो सकते हैं जहां यह स्पष्ट रूप से प्रकार घोषित करने के लिए समझ में आता है - शायद आपके पास एक तरीका है जो एक रिटर्न देता है List<T>, लेकिन आप इसे एक के रूप में मानना चाहते हैंIEnumerable<T>आपकी विधि में। यह सुनिश्चित करने के लिए कि आप इंटरफ़ेस का उपयोग कर रहे हैं, इंटरफ़ेस प्रकार के चर की घोषणा यह स्पष्ट कर सकती है। या, शायद, आप एक प्रारंभिक मूल्य के बिना एक चर घोषित करना चाहते हैं - क्योंकि यह तुरंत कुछ शर्त के आधार पर एक मूल्य प्राप्त करता है। उस मामले में आपको प्रकार की आवश्यकता है। यदि प्रकार की जानकारी उपयोगी या आवश्यक है, तो आगे बढ़ें और इसका उपयोग करें। मुझे लगता है, हालांकि, आमतौर पर यह आवश्यक नहीं है और अधिकांश मामलों में इसके बिना कोड को पढ़ना आसान है।

— tvanfosson
स्रोत

3

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

— स्टीव ब्रोइलार्ड

3

एह, मुझे पढ़ने में आसानी होती है जब टाइप बाईं ओर होता है। ReSharper का उपयोग करना, मुझे सही रास्ते पर टाइप को फिर से टाइप करने की आवश्यकता नहीं है, इसलिए यह मुझे परेशान नहीं करता है।

— ब्लूराजा - डैनी पफ्लुघोटे

1

@ ब्ल्यूराजा - मुझे लगता है कि अच्छे चर नामों का उपयोग आमतौर पर समझने के लिए वास्तविक प्रकार के साथ परेशान करने की आवश्यकता को समाप्त करता है। Intellisense अभी भी "var" परिभाषित चर पर उपलब्ध है, इसलिए मुझे कोडिंग करते समय उस पर विधि / संपत्ति चुनने के लिए प्रकार जानने की आवश्यकता नहीं है।

— tvanfosson

2

यह इतना नहीं है जब आप कोडिंग कर रहे हों जैसा कि तब होता है जब आपको कोड पढ़ना होता है।

— ब्लूराजा - डैनी पफ्लुगुएफ्ट

1

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

— एंथनीवजोन

91

दोनों में से कोई भी बिल्कुल सच नहीं है; varपठनीयता पर सकारात्मक और नकारात्मक दोनों प्रभाव हो सकते हैं। मेरी राय में, varनिम्नलिखित में से कोई भी सत्य होने पर उपयोग किया जाना चाहिए:

प्रकार गुमनाम है (ठीक है, आपके पास यहां कोई विकल्प नहीं है, क्योंकि इस मामले में यह संस्करण होना चाहिए)
निर्दिष्ट अभिव्यक्ति के आधार पर प्रकार स्पष्ट है (अर्थात var foo = new TypeWithAReallyLongNameTheresNoSenseRepeating())

varकोई प्रदर्शन प्रभाव नहीं है, क्योंकि यह वाक्यात्मक चीनी है; कंपाइलर प्रकार को संक्रमित करता है और इसे आईएल में संकलित करने के बाद इसे परिभाषित करता है; वास्तव में इसके बारे में कुछ भी गतिशील नहीं है।

— एडम रॉबिन्सन
स्रोत

1

दोनों पर सहमत हों, हालांकि मेरे पास दूसरे मामले पर लंबे प्रतिबंध हैं, अगर एक प्रकार है कि लंबे समय तक यह आमतौर पर नेस्टेड जेनेरिक तर्कों के बहुत से सामान्य प्रकार है, तो उस मामले में एक जोरदार टाइप "टाइपटाइटिललॉन्ग नेमTheresNoSenseRepeating" के बराबर शॉर्ट-टाइप अधिक समझ में आता है

— आयन टोडिरेल

12

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

— स्टीव ब्रोइलार्ड

2

@ पाठ: मुझे आपसे सहमत होना होगा; एक "संक्षिप्त प्रकार" (जो मुझे लगता है कि विशिष्ट जेनेरिक प्रकार से केवल नाम को छोटा करने के उद्देश्य से विरासत में मिला है) बनाना एक अच्छा अभ्यास नहीं है; यह आपको डुप्लिकेट करने और जेनेरिक प्रकार से किसी भी कंस्ट्रक्टर से गुजरने की आवश्यकता होगी, साथ ही आपको एक अलग प्रकार से गुजरने से रोकता है जो जेनेरिक प्रकार से फ़ंक्शन के लिए विरासत में मिलता है। typedefजब आप ऐसा नहीं करते हैं तो आप विरासत का उपयोग कर रहे हैं ।

— एडम रॉबिन्सन

7

varप्रकार स्पष्ट होने पर उपयोग करें ? हो सकता है, लेकिन सही लाभ तब होता है जब प्रकार कोई फर्क नहीं पड़ता। यदि आप ऐसी चीजें कर रहे हैं var customers = whatever; var query = from c in customers select stuffतो इससे कोई फर्क नहीं पड़ता कि 'ग्राहकों' का सही प्रकार क्या है। यह स्पष्ट है कि आप इसका उपयोग कैसे कर सकते हैं, और यह पर्याप्त है। और यदि वास्तविक प्रकार बोझिल है, तो इसे दबाना सार्थक है।

— जोरेन

2

@ क्रिस्तोफर: मैं टैग्स की गड़बड़ी को खत्म करने के लिए समझ सकता हूं, लेकिन उन्हें एक कक्षा में लपेटना एक स्वीकार्य विकल्प नहीं है (आईएमओ), क्योंकि तब आप उस सामान्य प्रकार के किसी अन्य (वैध) बच्चे के वर्ग की संभावना को काट देंगे। एक वैध पैरामीटर। मैं इसके बजाय using ShortType = LongGenericType<A,B,C>एक फ़ाइल के शीर्ष पर एक निर्देश का उपयोग करूंगा , क्योंकि यह एक ही पठनीयता देता है, इसके लिए आपको निर्माणकर्ताओं को फिर से बनाने की आवश्यकता नहीं है, और उम्मीदवार बनने से बाल वर्गों को समाप्त नहीं करता है।

— एडम रॉबिन्सन

68

एरिक लिपर्ट से, सी # टीम में एक वरिष्ठ सॉफ्टवेयर डिज़ाइन इंजीनियर:

varकीवर्ड क्यों पेश किया गया था ?

दो कारण हैं, एक जो आज मौजूद है, एक जो 3.0 में फसल करेगा।

पहला कारण यह है कि यह कोड सभी अतिरेक के कारण अविश्वसनीय रूप से बदसूरत है:

Dictionary<string, List<int>> mylists = new Dictionary<string, List<int>>();

और यह एक सरल उदाहरण है - मैंने बदतर लिखा है। किसी भी समय आपको एक ही चीज़ को दो बार टाइप करने के लिए मजबूर किया जाता है, यह एक अतिरेक है जिसे हम हटा सकते हैं। लिखने के लिए बहुत अच्छा है

var mylists = new Dictionary<string,List<int>>();

और संकलक को बताएं कि असाइनमेंट पर आधारित प्रकार क्या है।

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

जोर मेरा। पूरा लेख, C # 3.0 अभी भी सांख्यिकीय रूप से टाइप किया गया है, ईमानदार! , और आगामी श्रृंखला बहुत अच्छी हैं।

यह वही varहै जिसके लिए है अन्य उपयोग शायद इतनी अच्छी तरह से काम नहीं करेंगे। JScript, VBScript या डायनेमिक टाइपिंग की तुलना कुल बंक है। फिर से नोट, varहै आवश्यक आदेश .NET में कुछ अन्य सुविधाओं के काम करने के लिए।

— डस्टमैन
स्रोत

मुझे लिपर्ट का तर्क अजीब लगता है। कोई भी दूसरे प्रकार का नाम नहीं रखता है, उन्होंने Intellisense को उनके लिए लिखने दिया, लेकिन फिर वह चारों ओर घूमता है और दावा करता है कि var बेहतर है क्योंकि कंपाइलर / Intellisense इसे काम करता है। आप इसे दोनों तरीकों से नहीं कर सकते हैं!

— डेव

5

C # टीम intellisense को नियंत्रित नहीं करती है, वे संकलक को नियंत्रित करते हैं। किसी भी घटना में यह मुख्य मुद्दा नहीं है। मुझे नहीं लगता कि अकेले टाइपिंग को बचाने के लिए var ने 100 अंक बनाए होंगे।

— डस्टमैन

@ डस्टमैन: var टाइपिंग को बिल्कुल भी नहीं बचाता है। यह आपको अधिक लिखता है!

— पियोट्र पर्क

53

मुझे लगता है कि var के उपयोग को बुद्धिमानी से चुने गए चर नामों के साथ जोड़ा जाना चाहिए।

मुझे फ़ॉरवर्ड स्टेटमेंट में var का उपयोग करने में कोई समस्या नहीं है, बशर्ते यह इस तरह न हो:

foreach (var c in list) { ... }

यदि यह इस तरह से अधिक थे:

foreach (var customer in list) { ... }

... तो कोड पढ़ने वाले किसी व्यक्ति को यह समझने की अधिक संभावना होगी कि "सूची" क्या है। यदि आपके पास सूची चर के नाम पर नियंत्रण है, तो यह और भी बेहतर है।

वही अन्य स्थितियों पर लागू हो सकता है। यह बहुत बेकार है:

var x = SaveFoo(foo);

... लेकिन यह समझ में आता है:

var saveSucceeded = SaveFoo(foo);

प्रत्येक अपने स्वयं के, मुझे लगता है। मैंने खुद को ऐसा करते हुए पाया है, जो सिर्फ पागल है:

var f = (float)3;

मुझे 12-चरणीय var प्रोग्राम के कुछ प्रकार चाहिए। मेरा नाम मैट है, और मैं (ab) var का उपयोग करता हूं।

— दर्शाता है
स्रोत

6

अच्छी तरह से केवल एक चीज "var f = (float) 3;" यह है कि यह "var f = 3f" या "var f = 3.0 (एकल परिशुद्धता चूसना कारण)" होना चाहिए।

— माइकलजी

3

हे हाँ 3f या 3.0 रास्ता तय करना है! हमें var maniacs को एक साथ रहना है!

— मैट हैमिल्टन

27

उस पहले उदाहरण में वास्तविक समस्या "सूची" है, न कि "सी"। "की सूची" क्या ? "सूची" का नाम बदलकर "ग्राहकों", या "ग्राहकोंवेहोवेनी", या "करंटकस्टमर्स", या कुछ और अधिक वर्णनात्मक होना चाहिए। और एक बार आपके पास, "ग" जैसा हो सकता है, क्योंकि आप पहले से ही जानते हैं कि इसमें क्या होगा।

— रयान ल्यूडी

4

हे मैट! मेरा नाम केनी है और मैं एक वारडक्ट हूं।

— केनी

var मैटनिमिल = "ल्यूक स्काईवॉकर"; // इसमें से एक टन छीन लिया

— बिन्नोज एंटनी

40

हमने "विकास के लिए कोड, लोगों को नहीं मशीनों" को इस धारणा के आधार पर अपनाया है कि आप नए विकास की तुलना में कई बार लंबे समय तक रखरखाव मोड में रहते हैं।

मेरे लिए, वह तर्क यह बताता है कि कंपाइलर "जानता है" किस प्रकार का चर है - निश्चित रूप से, आप पहली बार अमान्य कोड नहीं लिख सकते क्योंकि कंपाइलर आपके कोड को कंपाइल करने से रोकता है, लेकिन जब अगला डेवलपर कोड पढ़ रहा हो 6 महीने के समय में उन्हें यह पता लगाने में सक्षम होना चाहिए कि चर सही या गलत तरीके से क्या कर रहा है और मुद्दों के कारण को जल्दी से पहचान सकता है।

इस प्रकार,

var something = SomeMethod();

हमारे कोडिंग मानकों द्वारा घोषित किया गया है, लेकिन हमारी टीम में निम्नलिखित को प्रोत्साहित किया जाता है क्योंकि यह पठनीयता बढ़ाता है:

var list = new List<KeyValuePair<string, double>>();
FillList( list );
foreach( var item in list ) {
   DoWork( item ); 
}

— डेक्सटर
स्रोत

4

मैंने पाया है कि ("लोगों के लिए कोड, मशीनें नहीं") एक उत्कृष्ट दिशानिर्देश होने के लिए - इसके परिणामस्वरूप बेहतर कोड हो सकता है और समय से पहले अनुकूलन से बचने में मदद मिलती है।

— थानाटॉस

3

मुझे var सूची = new KeyValuePair <string, double> नहीं मिल रही है? मेरे लिए एक सूची से ज्यादा की चीज हो सकती है।

— टीटीटी

"लोगों के लिए कोड, मशीनें नहीं" - आमीन।

— user1068352

39

यह बुरा नहीं है, यह एक शैलीगत चीज है, जो व्यक्तिपरक है। यह विसंगतियों को जोड़ सकता है, जब आप var का उपयोग करते हैं और जब आप नहीं करते हैं।

चिंता का एक और मामला, निम्नलिखित कॉल में आप केवल उस कोड को देखकर नहीं बता सकते हैं जिसके द्वारा टाइप किया गया है CallMe:

var variable = CallMe();

यह मेरी मुख्य शिकायत है var के खिलाफ।

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

var callback = new Func<IntPtr, bool>(delegate(IntPtr hWnd) {
   ...
});

EDIT : जूलियन के इनपुट के आधार पर अंतिम कोड नमूना अपडेट किया गया

— आयन टोडिरेल
स्रोत

3

लेकिन क्या आपको वास्तव में उस रेखा पर सही प्रकार जानने की आवश्यकता है? आप जानते हैं कि CallMe कुछ देता है; क्या यह जानना पर्याप्त नहीं है कि स्थानीय चर नाम variableबनाया गया है? जब तक आप अपने उदाहरण का विस्तार नहीं करते, यह एक बहुत ठोस शिकायत नहीं है, IMO।

— रैंडोल्फो

2

यह क्रियात्मक नहीं होने के बारे में नहीं है, यह संकलक को आपके लिए सिंटैक्स चीनी नहीं करने देने के बारे में है। इस पर विचार करें: var getter ..., अब यह Func <object> getter ..., दूसरे के साथ आप जानते हैं कि आपको कोई पैरामीटर प्रदान नहीं करना है और यह क्या देता है। आप शुरू से जानते हैं "क्या करना है" और तेजी से निर्णय ले सकते हैं, जब कुछ डिजाइन या पुन: निर्माण कर सकते हैं। कुछ अधिक पात्रों की तुलना में सभी जानकारी हाथ में होना अधिक महत्वपूर्ण है। यह तभी सराहा जा सकता है जब आप बहुत सारे कोड के साथ काम कर रहे हों।

— इयोन टोडिएरेल

2

चूंकि हम सभी दृश्य स्टूडियो के बारे में वैसे भी बात कर रहे हैं, इसलिए अपने माउस को एक दूसरे के लिए चर पर मँडराते समय क्या बड़ी बात है और बस यह देखना है कि यह किस प्रकार का है? वैसे भी घोषणा को चलाने से बहुत बेहतर है।

— Rubys

3

सामान्य चर और फ़ंक्शन नाम ( variable, CallMe) खराब उदाहरण बनाते हैं। हालांकि, अगर CallMe()किसी तरह के "फोन एप्लिकेशन" में एक फ़ंक्शन था, तो var call = CallMe(); .... call.HangUp();बहुत अधिक समझ में आएगा।

— डैंको डर्बिएक

3

@ रैंडोल्फ: "एक दूसरे के लिए चर पर अपने माउस को घुमाने के बारे में क्या बड़ी बात है और सिर्फ यह देखना है कि यह किस प्रकार का है?" यह रखरखाव ओवरहेड में समय जोड़ता है ... साथ ही एक सेकंड में कीबोर्ड से माउस संदर्भ स्विच को गिनने के बजाय केवल हॉवर का समय है। मैं आपके बारे में नहीं जानता, लेकिन मैं एक समय सीमा के साथ काम करता हूं। हर बार मुझे यह जानने के लिए एक चर पर घूमना पड़ता है कि यह किस प्रकार का है, समय है कि मैं एक समस्या को ठीक करने में बेहतर खर्च कर सकता हूं।

— पॉवरलॉर्ड

36

वर बिल्कुल वैरिएंट की तरह नहीं है। चर अभी भी दृढ़ता से टाइप किया गया है, यह सिर्फ इतना है कि आप इसे इस तरह से प्राप्त करने के लिए चाबियाँ नहीं दबाते हैं। आप इसे देखने के लिए Visual Studio में इस पर मंडरा सकते हैं। यदि आप मुद्रित कोड पढ़ रहे हैं, तो संभव है कि आपको यह सोचने के लिए थोड़ा सोचना होगा कि प्रकार क्या है। लेकिन केवल एक ही रेखा है जो इसे घोषित करती है और कई लाइनें जो इसका उपयोग करती हैं, इसलिए चीजों को सभ्य नाम देना अभी भी सबसे अच्छा तरीका है जिससे आपके कोड का पालन करना आसान हो जाता है।

क्या Intellisense का उपयोग करना आलसी है? यह पूरे नाम से कम टाइपिंग है। या ऐसी चीजें हैं जो कम काम करती हैं लेकिन आलोचना के लायक नहीं हैं? मुझे लगता है कि वहाँ हैं, और var उनमें से एक है।

— केट ग्रेगरी
स्रोत

6

+1, केवल उस व्यक्ति पर ध्यान दें जिसका varकोई लेना-देना नहीं है Variant।

— user7116

27

सबसे अधिक संभावना समय आपको इसकी आवश्यकता होगी अनाम प्रकारों के लिए (जहां यह 100% आवश्यक है); लेकिन यह भी तुच्छ मामलों के लिए पुनरावृत्ति से बचा जाता है, और IMO लाइन को स्पष्ट करता है। मुझे एक साधारण आरंभीकरण के लिए दो बार टाइप देखने की आवश्यकता नहीं है।

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

Dictionary<string, List<SomeComplexType<int>>> data = new Dictionary<string, List<SomeComplexType<int>>>();

(कृपया ऊपर में hscroll को संपादित न करें - यह थोड़े बात साबित करता है !!!

बनाम:

var data = new Dictionary<string, List<SomeComplexType<int>>>();

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

static void DoSomething(IFoo foo) {Console.WriteLine("working happily") }
static void DoSomething(Foo foo) {Console.WriteLine("formatting hard disk...");}

// this working code...
IFoo oldCode = new Foo();
DoSomething(oldCode);
// ...is **very** different to this code
var newCode = new Foo();
DoSomething(newCode);

— मार्क ग्रेवेल
स्रोत

1

(जानकारी के लिए, आप इसी तरह के मुद्दों के लिए कुछ भी पर प्राप्त कर सकते हैं, जहां इस प्रकार एक अंतर्निहित रूपांतरण है)

— मार्क Gravell

1

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

— गर्त्जन

@TheVillageIdiot - मैं अपने संपादित वापस लुढ़का, क्योंकि इस अवसर पर hscroll बिंदु ;-p से संबंधित है

— मार्क Gravell

2

@ गर्जन - मेरा मस्तिष्क सीमित है; यदि यह जटिल है, तो मैं इसे दो बार नहीं देखना चाहता और तुलना (इंटरफ़ेस / कंक्रीट / आदि) शुरू करना चाहता हूं । मैं इसे एक बार देखकर खुश हूं और सोचता हूं कि "उनमें से एक के रूप में टाइप किया गया है"।

— मार्क Gravell

17

एक विशिष्ट मामला जहां var मुश्किल है: ऑफ़लाइन कोड समीक्षाएं, विशेष रूप से कागज पर किए गए।

आप उसके लिए माउस-ओवरों पर भरोसा नहीं कर सकते।

— जॉन लिमजप
स्रोत

17

क्यों बिल्ली आप कागज पर समीक्षा कर रहे हैं? पेड़ों के बारे में सोचो! ;)

— डस्टमैन

8

आपको var का उपयोग किए बिना एक ही समस्या हो सकती है। समस्या var नहीं है; समस्या खराब चर नाम है। यदि चर नामों को अच्छी तरह से चुना जाता है, तो var का उपयोग कोई मायने नहीं रखता है।

— रयान लूनी जूल

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

— Beep beep

परिवर्तनीय नाम अकेले समस्या का समाधान नहीं करते हैं जब तक कि आप आयु संकेतन पर वापस नहीं जाते हैं जहां प्रकार नाम का हिस्सा है।

— केविन गेल

17

मैं नहीं देखता कि क्या बड़ी बात है ..

var something = someMethod(); // Type of 'something' not clear <-- not to the compiler!

आपके पास अभी भी 'कुछ' पर पूर्ण जानकारी है, और किसी भी अस्पष्ट मामले के लिए आपके पास अपने यूनिट परीक्षण हैं, है ना? ( क्या आप? )

यह चरचराहट नहीं है, यह मंद नहीं है, और यह निश्चित रूप से गतिशील या कमजोर टाइपिंग नहीं है। यह इस तरह से लोगों को रोक रहा है:

List<somethinglongtypename> v = new List<somethinglongtypename>();

और उस कुल दिमाग को कम करना:

var v = new List<somethinglongtypename>();

अच्छा है, जितना अच्छा नहीं है:

v = List<somethinglongtypename>();

लेकिन तब यही बू के लिए है।

— फ्रीप डी-ऑरेंज
स्रोत

संकलक के लिए 'कुछ' का प्रकार बहुत स्पष्ट है, आंतरिक रूप से, "var" रिटर्न के प्रकार 'someMethod' पर सेट हो जाता है, यह संकलक के लिए स्पष्ट है, लेकिन प्रोजेक्ट पर काम करने वाले डेवलपर्स के लिए स्पष्ट नहीं हो सकता है। और बू मुझ पर जल्दी से बढ़ रहा है।

— स्टीफनबायर

नहीं, v = List<somethinglongtypename>();यह भी अच्छा नहीं है। एक नए चर को पेश करने और मौजूदा चर को असाइन करने के बीच अंतर करना महत्वपूर्ण है।

— हाईकोमेन्डर ४

वैसे यदि आपने मौजूदा दायरे में पहले 'v' को सौंपा है, तो यह एक मौजूदा के लिए असाइनमेंट है। अन्यथा यह नए चर 'v' के लिए असाइनमेंट है। आसान।

— फ्रीप डी-ऑरेंज

17

यदि कोई varकीवर्ड का उपयोग कर रहा है क्योंकि वे "प्रकार का पता लगाना" नहीं चाहते हैं, तो यह निश्चित रूप से गलत कारण है। varकीवर्ड एक गतिशील प्रकार के साथ एक चर पैदा नहीं करता, संकलक अभी भी प्रकार पता करने के लिए है। जैसा कि चर हमेशा एक विशिष्ट प्रकार होता है, यदि संभव हो तो कोड में प्रकार भी स्पष्ट होना चाहिए।

varकीवर्ड का उपयोग करने के अच्छे कारण उदाहरण के लिए हैं:

जहां यह आवश्यक है, यानी एक गुमनाम प्रकार के लिए एक संदर्भ घोषित करने के लिए।
जहां यह कोड को अधिक पठनीय बनाता है, यानी दोहराए जाने वाले घोषणाओं को हटाता है।

डेटा प्रकार लिखना अक्सर कोड का अनुसरण करना आसान बनाता है। यह दिखाता है कि आप किस प्रकार के डेटा का उपयोग कर रहे हैं, ताकि आपको पहले यह पता लगाने की ज़रूरत न हो कि कोड क्या करता है।

— Guffa
स्रोत

11

यह देखते हुए कि इंटेलीजेंस अब कितना शक्तिशाली है, मुझे यकीन नहीं है कि किसी वर्ग में सदस्य चर, या एक विधि में स्थानीय चर की तुलना में पढ़ने के लिए कोई भी संस्करण कठिन है जो दृश्यमान स्क्रीन क्षेत्र से परिभाषित होता है।

यदि आपके पास कोड की एक पंक्ति है जैसे कि

IDictionary<BigClassName, SomeOtherBigClassName> nameDictionary = new Dictionary<BigClassName, SomeOtherBigClassName>();

पढ़ने में बहुत आसान या कठिन है:

var nameDictionary = new Dictionary<BigClassName, SomeOtherBigClassName>();

— कॉलिन डेसमंड को प्रकट करता है
स्रोत

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

— फिंगलस

यह मूल रूप से एकमात्र कारण था कि उन्होंने इसे लागू किया (अनाम प्रकारों को घोषित करने में सक्षम होने के अलावा, लेकिन वे "var" को एक विशेष कीवर्ड बना सकते थे जो केवल अनाम प्रकारों के लिए था।)

— mqp

10

मुझे लगता है कि VAR के साथ प्रमुख बात केवल इसका उपयोग करना है जहां उपयुक्त हो, जब लिनेक की चीजें करते समय यह सुविधा देता है (और शायद अन्य मामलों में)।

अगर आपको मिल गया है किसी चीज़ के लिए एक प्रकार है, तो आपको इसका उपयोग करना चाहिए - ऐसा करने के लिए सरल आलस्य नहीं है (जैसा कि रचनात्मक आलस्य के विपरीत है जिसे आमतौर पर प्रोत्साहित किया जाता है - अच्छे प्रोग्रामर का काम आलसी होने के लिए बहुत कठिन काम होता है और माना जा सकता है पहली जगह में बात का स्रोत)।

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

याद रखने वाली दूसरी बात यह है कि इसका VB टाइप वैर नहीं है, जिसमें यह टाइप्स नहीं बदल सकता है - यह दृढ़ता से टाइप किया गया वैरिएबल है बस इसका यह है कि टाइप इनफर्टेड है (यही वजह है कि ऐसे लोग हैं जो तर्क देंगे कि इसके लिए अनुचित नहीं है इसका उपयोग करें, कहते हैं, एक अगल-बगल लेकिन मैं पठनीयता और स्थिरता दोनों के कारणों से असहमत हूं)।

मुझे संदेह है कि यह एक और दौड़ने वाला है (-:

Murph

— Murph
स्रोत

10

यकीन है, intआसान है, लेकिन जब चर का प्रकार होता है IEnumerable<MyStupidLongNamedGenericClass<int, string>>, तो संस्करण चीजों को बहुत आसान बनाता है।

— Blorgbeard बाहर हैं
स्रोत

2

इसके लिए +1। intबनाम varकुछ के बारे में परेशान करने के लिए है, लेकिन कई नेस्टेड सामान्य प्रकार varएक देवता बनाते हैं । यह वह जगह है जहाँ पर बार-बार नाम का उपयोग करना कोड की पठनीयता को नष्ट कर देता है।

— क्रिस किसान

यह इसका उपयोग करने के लिए बिल्कुल गलत कारण है। यदि आपका कोड नेस्टेड जेनेरिक प्रकार का उपयोग करता है, तो आपको इसके लिए एक विशिष्ट नामित वर्ग प्राप्त करना चाहिए। उदाहरण के लिए: class IntStringEnumerator : IEnumerable<MyStupidLongNamedGenericClass<int, string>>और फिर नए नाम का उपयोग करें। यह कोड को साफ करता है और बेहतर प्रकार का वर्णन करता है।

— xxbbcc

ठीक है, लेकिन मेरा उदाहरण सिर्फ हाइपरबोले था। IntStringEnumerator i = new IntStringEnumerator()अभी भी बहुत टाइपिंग है

— Blorgbeard

9

CodingHorror में इस मुद्दे पर पोस्ट से चोरी :

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

MyObject m = new ();

या यदि आप पैरामीटर पास कर रहे हैं:

व्यक्ति p = नया ("FirstName", "LastName);

जहां एक नई वस्तु के निर्माण में, कंपाइलर बाईं ओर से टाइप को संक्रमित करता है, न कि दाएं से। "Var" पर इसके अन्य फायदे हैं, इसका उपयोग क्षेत्र घोषणाओं में भी किया जा सकता है (कुछ अन्य क्षेत्र भी हैं जो इसे उपयोगी भी बना सकते हैं, लेकिन मैं इसमें नहीं मिलेगा)।

अंत में, यह सिर्फ अतिरेक को कम करने का इरादा नहीं था। मुझे गलत मत समझो, "var" अनाम प्रकारों / अनुमानों के लिए C # में बहुत महत्वपूर्ण है, लेकिन यहाँ उपयोग सिर्फ WAY ऑफ है (और मैं यह लंबे समय से कह रहा हूं) जैसा कि आप टाइप करते हैं। उपयोग किया जा रहा है। इसे दो बार टाइप करना बहुत बार होता है, लेकिन इसे शून्य बार घोषित करना बहुत कम है।

निकोलस पाल्डिनो .NET / C # MVP 20 जून, 2008 को 08:00 पूर्वाह्न

मुझे लगता है कि यदि आपकी मुख्य चिंता कम टाइप करना है - तो कोई तर्क नहीं है जो आपको इसका उपयोग करने से रोकने वाला है।

आप केवल करने के लिए जा रहे हैं, तो कभी व्यक्ति जो आपके कोड को देखती है, तो कौन परवाह करता है हो सकता है? अन्यथा, इस तरह से एक मामले में:

var people = Managers.People

यह ठीक है, लेकिन इस तरह से एक मामले में:

var fc = Factory.Run();

यह किसी भी प्रकार की शॉर्ट सर्किट को शॉर्ट सर्किट कर देता है जिससे मेरा मस्तिष्क कोड के 'इंग्लिश' से बनना शुरू कर सकता है।

अन्यथा, अपने सर्वोत्तम निर्णय और प्रोग्रामिंग 'शिष्टाचार' का उपयोग दूसरों के प्रति करें जिन्हें आपके प्रोजेक्ट पर काम करना पड़ सकता है।

— चलता है
स्रोत

4

ऊपर दिए गए आपके उदाहरण var का उपयोग न करने का तर्क नहीं हैं; वे अच्छे वर्णनात्मक चर नामों का उपयोग करने के लिए तर्क देते हैं। यदि, इसके बजाय [var fc = Factory.Run ();] आपके पास [bool fc = Factory.Run ();] हो, तो कोड कोई भी स्पष्ट नहीं होगा।

— रयान लुनडी

9

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

आप हर तरीके को बदले बिना अपने तरीकों के रिटर्न प्रकार को बदल सकते हैं जहां यह विधि कहलाती है। कल्पना कीजिए

...
List<MyClass> SomeMethod() { ... }
...

जिसका उपयोग किया जाता है

...
IList<MyClass> list = obj.SomeMethod();
foreach (MyClass c in list)
  System.Console.WriteLine(c.ToString());
...

यदि आप SomeMethod()एक को वापस करने के लिए प्रतिक्षेपक करना चाहते थे IEnumerable<MySecondClass>, तो आपको चर घोषणा (इसके अंदर भी) को बदलना होगाforeach आपको उस विधि का उपयोग करने वाले हर स्थान ) ।

अगर आप लिखेंगे

...
var list = obj.SomeMethod();
foreach (var element in list)
  System.Console.WriteLine(element.ToString());
...

इसके बजाय, आपको इसे बदलना नहीं होगा।

— MartinStettner
स्रोत

सहमत - सोच रहा था कि इस अच्छे साइड इफ़ेक्ट को क्यों नहीं टाल दिया जा रहा है क्योंकि कुछ अन्य लोकप्रिय प्रतिक्रियाओं में अधिक व्यक्तिपरक हैं।

— क्षेत्ररक्षण मेल

यह मेरे लिए आज का दिन है। मेरे पास एक फैक्ट्री क्लास है जो एक मेनमेनू क्लास की वापसी है। आज मैंने MainMenu का एक ही इंटरफेस के साथ एक MainMenu2 बनाया। मेरे पास परिवर्तन के बाद मेरा सभी ऐप कोड अछूता है!

— बजे मार्को स्टेफोली

8

@aku: एक उदाहरण कोड समीक्षा है। एक और उदाहरण परिदृश्यों को प्रतिबिंबित कर रहा है।

मूल रूप से मैं अपने माउस के साथ टाइप-हंटिंग नहीं जाना चाहता। यह उपलब्ध नहीं हो सकता है।

— erlando
स्रोत

2

यह दिलचस्प है कि आप कहते हैं कि क्योंकि var रिफैक्टिंग को सरल बना सकता है। यदि आपने var का उपयोग किया है तो आपके पास नहीं है। अब आप हमेशा आईडीई के रीफैक्टरिंग टूल्स पर भरोसा कर सकते हैं, लेकिन आप जानते हैं, आप हमेशा आईडीई पर टाइप के लिए भी भरोसा कर सकते हैं :)

— फ्रेड

8

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

सी # varबहुत सुंदर है कि यह गतिशील टाइपिंग की तरह दिखता है , लेकिन वास्तव में स्थिर टाइपिंग है - कंपाइलर सही उपयोग को लागू करता है।

आपके चर का प्रकार वास्तव में उतना महत्वपूर्ण नहीं है (यह पहले कहा जा चुका है)। यह संदर्भ से अपेक्षाकृत स्पष्ट होना चाहिए (अन्य चर और विधियों के साथ इसकी बातचीत) और इसका नाम - ग्राहक सूची में शामिल होने की उम्मीद न करें int...

मैं अभी भी यह देखने के लिए इंतजार कर रहा हूं कि मेरे मालिक इस मामले के बारे में क्या सोचते हैं - मुझे 3.5 में किसी भी नए निर्माण का उपयोग करने के लिए एक कंबल "आगे बढ़ो" मिला, लेकिन हम रखरखाव के बारे में क्या करेंगे?

— डैरन थॉमस
स्रोत

7

के बीच आपकी तुलना में IEnumerable<int>और IEnumerable<double>आपको चिंता करने की आवश्यकता नहीं है - यदि आप गलत प्रकार से गुजरते हैं तो आपका कोड वैसे भी संकलन नहीं करेगा।

प्रकार-सुरक्षा के बारे में कोई चिंता नहीं है, जैसा varकि गतिशील नहीं है । यह सिर्फ कंपाइलर मैजिक है और आपके द्वारा की गई किसी भी प्रकार की असुरक्षित कॉलें पकड़ी जाएंगी।

Var Linq के लिए बिल्कुल आवश्यक है:

var anonEnumeration =
    from post in AllPosts()
    where post.Date > oldDate
    let author = GetAuthor( post.AuthorId )
    select new { 
        PostName = post.Name, 
        post.Date, 
        AuthorName = author.Name
    };

अब अंतर्मुहूर्त में एनोन्यूमरेशन को देखें और यह कुछ इस तरह दिखाई देगाIEnumerable<'a>

foreach( var item in anonEnumeration ) 
{
    //VS knows the type
    item.PostName; //you'll get intellisense here

    //you still have type safety
    item.ItemId;   //will throw a compiler exception
}

C # कंपाइलर बहुत चालाक है - अलग-अलग प्रकार के उत्पन्न होने पर उनके गुण मिलान के समान ही उत्पन्न प्रकार होंगे।

उस के बाहर, जब तक आपके पास अंतर्मुखी है, यह varसंदर्भ को स्पष्ट करने के लिए कहीं भी उपयोग करने के लिए अच्छा समझ में आता है ।

//less typing, this is good
var myList = new List<UnreasonablyLongClassName>();

//also good - I can't be mistaken on type
var anotherList = GetAllOfSomeItem();

//but not here - probably best to leave single value types declared
var decimalNum = 123.456m;

— प्रकट करता है
स्रोत

कृपया ध्यान दें IQueriable<T>इससे पहले कि यह छूट जाए : anonEnumeration.ToList();

— डेविड डायज़

@DavidDiez आप rephrase सकता है? आपके कथन का कोई मतलब नहीं है। मेरी कोड में से कोई भी संदर्भ के टुकड़े IQueryableया.ToList()

— कीथ

var anonEnumeration =     from post in AllPosts()     where post.Date > oldDate     let author = GetAuthor( post.AuthorId )     select new {          PostName = post.Name,          post.Date,          AuthorName = author.Name     };

एक वापस नहीं करता है IQueriable<T>?

— डेविड डायज़

1

@DavidDiez यह क्या पर निर्भर करता है AllPosts()रिटर्न - प्रश्नकर्ता को संदर्भित करता है List<T>तो मुझे लगता है कि ग्रहण किया। उस मामले में परिणाम यह है कि anonEnumerationप्रकार का होगा IEnumerable<'a>। अब अगर इसके बजाय AllPosts()रिटर्न मिलता है IQueryable<T>तो anonEnumerationबन जाएगा IQueryable<'a>( iनोटेबल में नोट नहीं ) - हालांकि उस स्थिति में मेरा कोड अभी भी काम करता है क्योंकि IQueryable<T>लागू होता है IEnumerable<T>। उनके बीच के अंतर के बारे में यहाँ बेहतर Q & As के भार हैं - यहाँ मेरा मामला यह है कि 'aअनाम औरvar आपको इसे वैधानिक रूप से टाइप किए गए वैरिएबल पर असाइन करने की अनुमति मिलती है।

— कीथ

ओह्ह मैं देख रहा हूँ, इसे समझाने के लिए धन्यवाद :) मेरी टिप्पणी थी क्योंकि इसमें पुनरावृत्ति करना IQueryable<T>एक अच्छा अभ्यास नहीं है क्योंकि प्रत्येक पुनरावृत्ति में आप डीबी में एक वक्तव्य दे रहे हैं। *.ToList() IQueryable<T>उन्हें पुनरावृत्ति करने से पहले सुनिश्चित करें

— डेविड डायज़

7

मुझे लगता है कि यह आपके दृष्टिकोण पर निर्भर करता है। मुझे व्यक्तिगत रूप से var"दुरुपयोग" के कारण कोड के एक टुकड़े को समझने में कोई कठिनाई नहीं हुई है , और मेरे सहकर्मियों और मैं इसे बहुत अधिक उपयोग करते हैं। (मैं मानता हूं कि इस संबंध में Intellisense एक बहुत बड़ी सहायता है।) मैं इसे दोहराए गए क्रॉफ्ट को हटाने के तरीके के रूप में स्वागत करता हूं।

आखिरकार, अगर बयान पसंद है

var index = 5; // this is supposed to be bad

var firstEligibleObject = FetchSomething(); // oh no what type is it
                                            // i am going to die if i don't know

वास्तव में यह असंभव था कि किसी के साथ व्यवहार करने के लिए, कोई भी गतिशील रूप से टाइप की गई भाषाओं का उपयोग नहीं करेगा।

— MQP
स्रोत

संभवत: .Net 4 में जहां डायनामिक प्रकार आम जगह हैं, यह अधिक महत्वपूर्ण हो जाएगा?

— कॉलिन डेसमंड

2

इसके विपरीत, यदि आप अभी "var" द्वारा भ्रमित हैं, तो मैं उम्मीद करूंगा कि आप "डायनामिक" द्वारा अतिरिक्त रूप से भ्रमित होंगे। भगवान किसी को भी कभी भी एक गतिशील घोषित करते हैं और उसके बाद "var" का उपयोग करके एक संदर्भ बनाते हैं :)

— mqp

मेरा मतलब डायनेमिक डी = 52 जैसा था; var x = d; जो ठीक होना चाहिए।

— 13

7

मैं केवल तभी var का उपयोग करता हूं जब यह देखने के लिए स्पष्ट हो कि किस प्रकार का उपयोग किया जाता है।

उदाहरण के लिए, मैं इस मामले में var का उपयोग करूंगा, क्योंकि आप तुरंत देख सकते हैं कि x "MyClass" प्रकार का होगा:

var x = new MyClass();

मैं इस तरह के मामलों में var का उपयोग नहीं करूंगा, क्योंकि आपको कोड पर माउस को खींचना होगा और टूलटिप को देखना होगा कि किस प्रकार MyFunction रिटर्न करता है:

var x = MyClass.MyFunction();

विशेष रूप से, मैं ऐसे मामलों में कभी भी var का उपयोग नहीं करता जहाँ दाईं ओर भी कोई विधि नहीं है, लेकिन केवल एक मान है:

var x = 5;

(क्योंकि कंपाइलर को पता नहीं चल सकता है कि मुझे बाइट, शॉर्ट, इंट या जो भी चाहिए)

— क्रिश्चियन स्पीच
स्रोत

यदि दाहिने हाथ की ओर पर्याप्त उपयोग के औचित्य के लिए स्पष्ट नहीं है var, तो varसमस्या नहीं है: दाहिने हाथ की ओर समस्या है। यह वर्णनात्मक पर्याप्त नहीं है । Customer c = GetContext()है अभी भी स्पष्ट नहीं है और का उपयोग कर के अलावा कोई बेहतर var।

— जूलियनआर

6

मेरे लिए, var.NET में द्विभाषिकता क्यों महत्वपूर्ण है , इस बारे में प्रतिपक्षी महत्वपूर्ण है। उन C # प्रोग्रामर्स के लिए जिन्होंने VB .NET भी किया है, के फायदे varसहज रूप से स्पष्ट हैं। मानक C # की घोषणा:

List<string> whatever = new List<string>();

यह टाइप करने के VB .NET में समतुल्य है:

Dim whatever As List(Of String) = New List(Of String)

हालांकि, VB .NET में कोई भी ऐसा नहीं करता है। यह मूर्खतापूर्ण होगा, क्योंकि .NET के पहले संस्करण के बाद से आप यह करने में सक्षम हैं ...

Dim whatever As New List(Of String)

... जो परिवर्तनशील बनाता है और सभी को एक समान रूप से कॉम्पैक्ट लाइन में आरंभ करता है। आह, लेकिन क्या अगर तुम एक IList<string>नहीं, एक List<string>चाहते हैं? ठीक है, VB .NET में इसका मतलब है कि आपको यह करना होगा:

Dim whatever As IList(Of String) = New List(Of String)

जैसे आपको C # में करना होगा, और जाहिर है कि इसके varलिए उपयोग नहीं किया जा सकता है :

IList<string> whatever = new List<string>();

यदि आपको कुछ अलग होने के लिए प्रकार की आवश्यकता है , तो यह हो सकता है। लेकिन अच्छी प्रोग्रामिंग के बुनियादी सिद्धांतों में से एक अतिरेक को कम कर रहा है, और यही वास्तव में var करता है।

— रेयान लुंडी
स्रोत

1

अजीब बात है कि आप द्विभाषावाद का उल्लेख करते हैं, जो कि var के उपयोग को बढ़ावा देता है। Var कीवर्ड के प्रति मेरी दुश्मनी जावास्क्रिप्ट में मेरे प्रवाह से सीधे उपजी है! :)

— १०:१६ पर

varC # varमें जावास्क्रिप्ट के साथ कोई संबंध नहीं है । एक varसी # में -declared चर दृढ़ता से टाइप किया गया है।

— रेयान लुंडी

6

इसे अनाम प्रकारों के लिए उपयोग करें - यह वही है जो इसके लिए है। कुछ भी बहुत दूर एक उपयोग है। कई लोग जो सी पर पले-बढ़े हैं, मैं टाइप के लिए घोषणा के बाईं ओर देखने के आदी हूं। जब तक मुझे नहीं करना है, मैं दाईं ओर नहीं देखता हूं। varकिसी भी पुरानी घोषणा के लिए उपयोग करने से मुझे वह हर समय होता है, जो मुझे व्यक्तिगत रूप से असहज लगता है।

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

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

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

— नील हेविट
स्रोत

7

वाह। इस सूत्र में अब तक सामने आए तमाम तर्कों की अनदेखी करना और पूरी चर्चा को फिर से स्थापित करना काफी उपलब्धि है।

— कोनराड रुडोल्फ

यह 100% वर्णन करता है कि मैं 'var' के बारे में कैसा महसूस करता हूं, विशेषकर किसी को कोड लेने के दृष्टिकोण से। यदि यह पूरी तरह से लेटा हुआ है तो var का उपयोग मौलिक रूप से कार्य को बदल देता है। +1

— साइमन

6

परीक्षण के दौरान कई बार, मैं खुद को इस तरह का कोड पाता हूं:

var something = myObject.SomeProperty.SomeOtherThing.CallMethod();
Console.WriteLine(something);

अब, कभी-कभी, मैं देखना चाहूंगा कि कुछ स्वयं के पास क्या है, कुछऑथरथिंग उसी प्रकार का नहीं है जैसा कि कॉलमेथोड () देता है। चूँकि मैं var का उपयोग कर रहा हूँ, मैं अभी इसे बदलता हूँ:

var something = myObject.SomeProperty.SomeOtherThing.CallMethod();

इसके लिए:

var something = myObject.SomeProperty.SomeOtherThing;

Var के बिना, मुझे बाएं हाथ की तरफ भी घोषित प्रकार को बदलते रहना होगा। मुझे पता है कि यह मामूली है, लेकिन यह बहुत सुविधाजनक है।

— BFree
स्रोत

6

लगता varहै कि afficionados के लिए समय की बचत होती है, यह टाइप करने के लिए कम कीस्ट्रोक्स लेता है:

StringBuilder sb = new StringBuilder();

से

var sb = new StringBuilder();

यदि आप मुझ पर विश्वास नहीं करते हैं तो उन्हें गिनें ...

19 बनाम 21

मैं समझाता हूं कि मुझे क्या करना है, लेकिन बस इसे आज़माएं ... (आपकी अंतरंगता की वर्तमान स्थिति के आधार पर आपको हर एक के लिए कुछ और लिखना होगा)

और यह हर प्रकार के लिए सच है जिसे आप सोच सकते हैं !!

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

— रेव स्मॉलवुड
स्रोत

मैं stringBuilder sb = नया StringBuilder () गन्दा और स्पष्ट रूप से पहचानने के लिए लंबे समय तक दोहराव पाता हूं। यह अतिरिक्त शोर है। समस्या यह है कि यह निर्धारित करना कि कुछ कोड को समझने के लिए अतिरिक्त बौद्धिक प्रयास क्या होता है और यह बहुत ही व्यक्तिपरक है!

— ljs

"var का उपयोग कभी नहीं किया जाना चाहिए, जहां प्रकार ज्ञात नहीं है ..." - आप हमेशा इस प्रकार को जान सकते हैं, जैसा कि संकलक करता है। यह गतिशील टाइपिंग नहीं है, यह सिर्फ कंपाइलर को आपके लिए प्रकार निर्धारित करने देता है। लेकिन प्रकार कभी अज्ञात नहीं होता है।

— गैब्रियल मैगाना

5

मैं सभी जगहों पर var को विभाजित करता हूं, मेरे लिए एकमात्र संदिग्ध स्थान आंतरिक लघु प्रकार हैं, जैसे मैं int i = 3;ओवर पसंद करता हूंvar i = 3;

— robi-y
स्रोत

5

यह निश्चित रूप से चीजों को सरल बना सकता है, कल मैंने जो कोड लिखा था:

var content  = new Queue<Pair<Regex, Func<string, bool>>>();
...
foreach (var entry in content) { ... }

यह बिना किसी क्रिया के होगा var।

परिशिष्ट: वास्तविक प्रकार के आक्षेप के साथ भाषा के साथ बिताया गया थोड़ा समय (उदाहरण F #) यह दिखाएगा कि अभिव्यक्ति के प्रकार को सही तरीके से पूरा करने में कितने अच्छे संकलक हैं। यह निश्चित रूप से मतलब है कि मैं varजितना संभव हो उतना उपयोग कर सकता हूं, और अब एक स्पष्ट प्रकार का उपयोग करना इंगित करता है कि चर प्रारंभिक अभिव्यक्ति के प्रकार का नहीं है।

— रिचर्ड
स्रोत

हाँ, संकलक हमसे अधिक होशियार हैं, इस पर काबू पाएं!

— बेंजोल

5

कोई नहीं, सिवाय इसके कि आपको दो बार टाइप नाम नहीं लिखना है। http://msdn.microsoft.com/en-us/library/bb383973.aspx

— इग्नास आर
स्रोत