C # (.NET) डिज़ाइन फ़्लास [बंद]

Question 1

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

8 साल पहले बंद हुआ ।

सामान्य रूप से C # या .NET फ्रेमवर्क में कुछ सबसे बड़े डिज़ाइन दोष क्या हैं?

उदाहरण: कोई गैर-अशक्त स्ट्रिंग प्रकार नहीं है और IDataReader से मान प्राप्त करते समय आपको DBNull की जांच करनी होगी।

Question 2

मैं इस पोस्ट के साथ सशक्त रूप से सहमत हूं (उन लोगों के लिए, जो ToString की कमी की पूजा करते हैं, आपकी कक्षा के लिए एक कस्टम प्रारूप प्रदान करने के लिए डिबगर विशेषता है)।

उपरोक्त सूची के शीर्ष पर, मैं निम्नलिखित उचित अनुरोध भी जोड़ूंगा:

अशक्त मान प्रकारों के पूरक के रूप में अशक्त संदर्भ प्रकार,
किसी रचना के खाली निर्माता को ओवरराइड करने की अनुमति दें,
सीलबंद कक्षाओं को निर्दिष्ट करने के लिए सामान्य प्रकार की बाधाओं को अनुमति दें,
मैं यहां एक और पोस्टर से सहमत हूं, जो बाधाओं के रूप में इस्तेमाल होने पर मनमाने ढंग से निर्माण करने वाले हस्ताक्षरों का अनुरोध करता है। कहाँ T : new(string), या कहाँT : new(string, int)
मैं एक और पोस्टर के साथ यहां फिक्सिंग घटनाओं के बारे में भी सहमत हूं, दोनों खाली ईवेंट सूचियों के लिए और समवर्ती सेटिंग में (हालांकि बाद वाला आकर्षक है,)
ऑपरेटरों को विस्तार विधियों के रूप में परिभाषित किया जाना चाहिए, और वर्ग के स्थिर तरीकों के रूप में नहीं (या कम से कम स्थिर तरीकों के रूप में नहीं),
इंटरफेस के लिए स्थिर गुणों और विधियों की अनुमति दें (जावा में यह है, लेकिन C # नहीं है),
ऑब्जेक्ट आरंभीकरण में घटना की अनुमति दें (केवल फ़ील्ड और गुण वर्तमान में अनुमत हैं),
"ऑब्जेक्ट इनिशियलाइज़र" सिंटैक्स केवल ऑब्जेक्ट बनाते समय प्रयोग करने योग्य क्यों होता है? क्यों नहीं इसे किसी भी समय उपलब्ध कराया जाए, अर्थात।var e = new Foo(); e { Bar = baz };
द्विघात व्यवहार को ठीक करें ,
सभी संग्रहों में पुनरावृत्ति के लिए अपरिवर्तनीय स्नैपशॉट होना चाहिए (अर्थात। संग्रह को संशोधित करने से पुनरावृत्त को अमान्य नहीं करना चाहिए),
tuples को जोड़ना आसान है, लेकिन एक कुशल बंद बीजगणितीय प्रकार जैसे " Either<T>" नहीं है, इसलिए मुझे बंद बीजीय प्रकार को घोषित करने और उस पर मेल खाने वाले संपूर्ण पैटर्न को लागू करने का कुछ तरीका पसंद आएगा (मूल रूप से आगंतुक पैटर्न के लिए प्रथम श्रेणी का समर्थन, लेकिन कहीं अधिक कुशल); तो बस enums ले लो, उन्हें विस्तृत पैटर्न मिलान समर्थन के साथ विस्तारित करें, और अमान्य मामलों की अनुमति न दें,
मुझे सामान्य रूप से मेल खाने वाले पैटर्न के लिए समर्थन पसंद है, लेकिन ऑब्जेक्ट प्रकार के परीक्षण के लिए बहुत कम से कम; मैं भी एक और पोस्ट में प्रस्तावित सिंटैक्स को पसंद करता हूं,
मैं एक और पोस्ट से सहमत हूं कि System.IOकक्षाएं, जैसे Stream, कुछ खराब तरीके से डिज़ाइन की गई हैं; किसी भी इंटरफ़ेस जिसे फेंकने के लिए कुछ कार्यान्वयन की आवश्यकता होती NotSupportedExceptionहै, एक खराब डिज़ाइन है,
IListकी तुलना में यह बहुत सरल होना चाहिए; वास्तव में, यह कई ठोस संग्रह इंटरफेस के लिए सही हो सकता है, जैसे ICollection,
उदाहरण के लिए, IDEDIA जैसे अपवादों को फेंकने के बहुत सारे तरीके
मैं जावा में उपलब्ध तुलना में बेहतर तरीके से जांचे गए अपवादों को पसंद करूंगा (यह कैसे किया जा सकता है, इसके लिए प्रकार और प्रभाव प्रणाली पर शोध देखें),
जेनेरिक विधि अधिभार संकल्प में विभिन्न कष्टप्रद कोने मामलों को ठीक; उदाहरण के लिए, दो अतिभारित विस्तार विधियों को प्रदान करने का प्रयास करें, एक जो संदर्भ प्रकारों पर काम करता है, और दूसरा अशक्त संरचना प्रकारों पर, और देखें कि आपके प्रकार का अनुमान कैसा लगता है,
इंटरफेस पर फ़ील्ड और सदस्य नामों को सुरक्षित रूप से प्रतिबिंबित करने का एक तरीका प्रदान करता है INotifyPropertyChanged, जैसे कि फ़ील्ड नाम को स्ट्रिंग के रूप में लेना; आप एक विस्तार विधि का उपयोग करके ऐसा कर सकते हैं जो एक MemberExpression, यानी के साथ एक लंबोदर लेता है । () => Foo, लेकिन यह बहुत कुशल नहीं है,
- अपडेट: C # 6.0 ने nameof()एकल सदस्य नामों के लिए ऑपरेटर को जोड़ा , लेकिन यह जेनरिक में काम नहीं करता ( nameof(T) == "T"वास्तविक प्रकार-तर्क के नाम के बजाय: आपको अभी भी करने की आवश्यकता है typeof(T).Name)) - और न ही यह आपको "पथ" स्ट्रिंग प्राप्त करने की अनुमति देता है , जैसे nameof(this.ComplexProperty.Value) == "Value"इसके संभावित अनुप्रयोगों को सीमित करना।
इंटरफेस में ऑपरेटरों को अनुमति दें, और सभी कोर नंबर प्रकारों को लागू करें IArithmetic; अन्य उपयोगी साझा ऑपरेटर इंटरफेस भी संभव हैं,
ऑब्जेक्ट फ़ील्ड्स / प्रॉपर्टीज़ को म्यूट करना या बहुत कम से कम, अपरिवर्तनीय फ़ील्ड्स को एनोटेट करने की अनुमति देना और टाइप चेकर को लागू करने की अनुमति देना (बस इसे गेट्टर-ओनली प्रॉपर्टी फ़ेर क्रिसिस के रूप में मानें, यह कठिन नहीं है!) वास्तव में, दोनों को होने का कोई मतलब नहीं है क्योंकि खेतों और संपत्तियों को अधिक समझदार तरीके से एकीकृत करें; C # 3.0 के स्वचालित गुण इस दिशा में एक पहला कदम है, लेकिन वे बहुत दूर नहीं जाते हैं,
- अद्यतन: जबकि C # में readonlyकीवर्ड था, और C # 6.0 ने केवल-पढ़ने के लिए ऑटो-गुण जोड़े, हालांकि यह अपरिवर्तनीय प्रकारों और मूल्यों के लिए सही भाषा समर्थन जितना कठोर नहीं है।
निर्माणकर्ताओं की घोषणा को सरल बनाना; मुझे F # का दृष्टिकोण पसंद है, लेकिन यहां दूसरे पद के लिए वर्ग नाम के बजाय बस "नए" की आवश्यकता है, कम से कम,

बस इतना ही काफी है। ये सभी परेशानियां हैं जो मैंने पिछले सप्ताह में की हैं। मैं शायद घंटों तक जा सकता था अगर मैं वास्तव में अपना दिमाग लगाता। C # 4.0 पहले से ही नाम, वैकल्पिक और डिफ़ॉल्ट तर्क जोड़ रहा है, जिसे मैं सशक्त रूप से अनुमोदित करता हूं।

अब एक अनुचित अनुरोध के लिए:

यह वास्तव में अच्छा होगा , अगर C # / CLR, कंस्ट्रक्टर पॉलीमॉर्फिज़्म का समर्थन कर सकता है, अर्थात। जेनेरिक से अधिक जेनेरिक,

मान जाओ ना? :-)

Question 3

Reset()विधि पर IEnumerator<T>एक गलती थी (इटरेटर ब्लॉकों के लिए, भाषा कल्पना भी मांग है कि यह एक अपवाद फेंकता है)
प्रतिबिंब तरीकों कि वापसी सरणियों थे, एरिक के विचार में, एक गलती
सरणी सह-अस्तित्व था और एक विषमता बनी हुई थी
- अद्यतन करें: .NET 4.0 के साथ C # 4.0 ने जेनेरिक इंटरफेस (जैसे IEnumerable<out T>और Func<in T, out TResult>, लेकिन ठोस प्रकार (पसंद नहीं List<T>) को सहसंयोजक / विरोधाभासी समर्थन जोड़ा ।
ApplicationException बल्कि पक्ष से बाहर गिर गया - क्या वह गलती थी?
सिंक्रनाइज़ किए गए संग्रह - एक अच्छा विचार है, लेकिन वास्तव में उपयोगी नहीं है: आपको आमतौर पर कई कार्यों को सिंक्रनाइज़ करने की आवश्यकता होती है (Contains तब Add) , इसलिए एक संग्रह जो अलग-अलग कार्यों को सिंक्रनाइज़ करता है, वह सब उपयोगी नहीं है
- अपडेट करें: प्रकार , के साथ , ,System.Collections.ConcurrentTryAddGetOrAddTryRemove , आदि .NET फ्रेमवर्क 4.0 में जोड़ा गया था - हालांकि तरीकों कि एक कारखाने प्रतिनिधि स्वीकार की गारंटी नहीं देते कारखाने केवल प्रति कुंजी एक बार सक्रिय किया जाएगा।
अधिक उपयोग using/ lockपैटर्न से बना हो सकता है - शायद उन्हें फिर से प्रयोग करने योग्य (एक्स्टेंसिबल?) सिंटैक्स साझा करने की अनुमति देता है; आप इसे वापस IDisposableकरके और उपयोग करके अनुकरण कर सकते हैंusing , लेकिन यह स्पष्ट हो सकता था
इटरेटर ब्लॉक: समय-समय पर (आलस्य के बजाय) तर्कों की जाँच करने का कोई सरल तरीका नहीं। ज़रूर, आप दो जंजीर तरीके लिख सकते हैं, लेकिन यह बदसूरत है
सरल अपरिवर्तनीयता अच्छी होगी; C # 4.0 थोड़ा मदद करता है , लेकिन काफी पर्याप्त नहीं है
कोई "यह रेफ-टाइप पैरामीटर अशक्त नहीं हो सकता" समर्थन - हालांकि अनुबंध (4.0 में) कुछ हद तक इसके साथ मदद करते हैं। लेकिन सिंटैक्स की तरह Foo(SqlConnection! connection)(कि एक अशक्त-जांच इंजेक्ट /throw ) अच्छा होगा ( int?आदि के विपरीत )
- अद्यतन: यह C # 8.0 में तय किया गया है ।
जनरेटर के साथ ऑपरेटरों और गैर-डिफ़ॉल्ट बिल्डरों के समर्थन की कमी; C # 4.0 के साथ dynamicइसे थोड़ा हल करता है , या आप इसे सक्षम कर सकते हैं इस तरह से
इटरेटर वैरिएबल थोड़ी देर में बाहर घोषित किया जा रहा हैforeach विस्तार , जिसका अर्थ है कि एनॉन-तरीके / लैम्ब्डा एकल चर को कैप्चर करते हैं, बजाय एक प्रति चलना (थ्रेडिंग / एसिंक्स / आदि के साथ दर्दनाक)
- अद्यतन: यह C # 5.0 में तय किया गया था ।

Question 4

TextWriter एक बेस है StreamWriter वर्ग है। WTF?

वह मुझे हमेशा चरम पर ले जाता है।

Question 5

एक छोटा सी # पालतू जानवर - कंस्ट्रक्टर सी ++ / जावा सिंटैक्स का उपयोग करते हैं, कंस्ट्रक्टर वर्ग के समान नाम है।

New() या ctor() बहुत अच्छा होता।

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

Question 6

मैं नहीं समझता कि आप ऐसा नहीं कर सकते

जहां T: नया (U)

तो आप घोषणा करते हैं कि सामान्य प्रकार T में एक गैर-डिफ़ॉल्ट निर्माता है।

संपादित करें:

मैं यह करना चाहता हूँ:

public class A 
{
    public A(string text) 
    {

    }
}


public class Gen<T> where T : new(string text) 
{

}

Question 7

मैं वास्तव में आश्चर्यचकित हूं कि मैं यह उल्लेख करने वाला पहला व्यक्ति हूं:

ADO.NET टाइप किए गए डेटा सेट अशक्त स्तंभों को अशक्त प्रकारों के गुणों के रूप में उजागर नहीं करते हैं। आपको यह लिखने में सक्षम होना चाहिए:

int? i = myRec.Field;
myRec.Field = null;

इसके बजाय, आपको यह लिखना होगा, जो सिर्फ बेवकूफ है:

int? i = (int?)myRec.IsFieldNull() ? (int?)null : myRec.Field;
myRec.SetFieldNull();

यह .NET 2.0 में कष्टप्रद था, और यह अब और भी अधिक कष्टप्रद है कि आपको अपने अच्छे नीम LINQ प्रश्नों में उपरोक्त की तरह गुड़-पकौड़ी का उपयोग करना होगा।

यह भी कष्टप्रद है कि उत्पन्न Add<TableName>Rowविधि इसी प्रकार अशक्त प्रकार की धारणा के प्रति असंवेदनशील है। उत्पन्न होने के बाद से सभी और अधिकTableAdapter विधियों के ।

.NET में बहुत कुछ नहीं है जो मुझे महसूस करता है कि देव टीम ने कहा "ठीक है, लड़कों, हम काफी करीब हैं - इसे शिप करें!" लेकिन यह सुनिश्चित करता है।

Question 8

मैं स्ट्रीम, StringWriter, StringReader, TextReader, TextWriter वर्गों का बड़ा प्रशंसक नहीं हूं ... यह सहज नहीं है कि क्या है।
IEnumerable.Reset पुनरावृत्तियों के लिए एक अपवाद फेंक। मेरे पास कुछ थर्ड पार्टी कंपोनेंट्स हैं जो डेटाबाउंड के दौरान हमेशा रीसेट कहते हैं, मुझे इनका उपयोग करने के लिए पहले एक सूची में डालना होगा।
Xml Serializer में ID Analytics तत्वों को क्रमांकित होना चाहिए
मैं पूरी तरह से HttpWebRequest और FTP API के बारे में भूल गया कि मेरे दर्द में क्या है .... (टिप्पणी निकोलस के लिए धन्यवाद मुझे यह याद दिलाने के लिए :-)

संपादित करें
5. मेरा एक और झुंझलाहट है कि कैसे System.Reflection.BindingFlags, आपके उपयोग करने की विधि के आधार पर अलग-अलग उपयोग करता है। FindFields में उदाहरण के लिए CreateInstance या SetField का क्या अर्थ है? यह एक ऐसा मामला है जहां उन्होंने इस गणना के पीछे के अर्थ को ओवरलोड किया है जो भ्रामक है।

Question 9

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

वीबी:

Dim a = Function(x) x * (x - 1)

सी#

यह अच्छा होगा यदि यह कर सके:

var a = x => x * (x - 1);

ऐसा करने के बजाय:

Func<int, int> a = x => x * (x - 1);

मुझे लगता है कि यह बहुत लंबा नहीं है, लेकिन कोड गोल्फ में हर चरित्र बहुत मायने रखता है! क्या वे उस समय को ध्यान में नहीं रखते हैं जब वे इन प्रोग्रामिंग भाषाओं को डिज़ाइन करते हैं? :)

Question 10

System.Object वर्ग:
- समान और GetHashCode - सभी कक्षाएं तुलनीय या धोने योग्य नहीं हैं, उन्हें एक इंटरफ़ेस में स्थानांतरित किया जाना चाहिए। IEquitable या IComparable (या समान) दिमाग में आता है।
- ToString - सभी वर्गों को एक स्ट्रिंग में नहीं बदला जा सकता है, इसे एक इंटरफ़ेस में स्थानांतरित किया जाना चाहिए। माननीय (या समान) दिमाग में आता है।
ICollection.SyncRoot संपत्ति:
- खराब डिजाइन को बढ़ावा देता है, एक बाहरी ताला लगभग हमेशा अधिक उपयोगी होता है।
शुरुआत से ही जेनरिक होनी चाहिए:
- System.Collections नाम स्थान और अधिक या कम अप्रचलित वर्गों और इंटरफेस की एक बहुत कुछ शामिल।

Question 11

मुझे चिढ़ाने वाली चीजों में एक है Predicate<T> != Func<T, bool>विरोधाभास। वे दोनों प्रकार के प्रतिनिधि हैं T -> boolऔर अभी तक वे असाइनमेंट संगत नहीं हैं।

Question 12

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

Question 13

हम अधिकार के बारे में बहुत कुछ जानते हैं OO तकनीकों के । Decoupling, अनुबंध द्वारा प्रोग्रामिंग, अनुचित विरासत से बचने, अपवादों का उचित उपयोग, खुला / बंद प्रिंसिपल, लिस्कोव प्रतिस्थापन, और इसी तरह। अभी तक, .Net फ्रेमवर्क सर्वोत्तम प्रथाओं को नियोजित नहीं करते हैं।

मेरे लिए .Net के डिजाइन में सबसे बड़ा दोष दिग्गजों के कंधों पर खड़ा नहीं है; आदर्श प्रोग्रामिंग से कम को बढ़ावा देने के लिए प्रोग्रामर की जनता के लिए जो अपने ढांचे का उपयोग करते हैं ।

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

Question 14

मुझे C # स्विच स्टेटमेंट पसंद नहीं है।

मैं कुछ इस तरह से चाहूंगा

switch (a) {
  1    : do_something;
  2    : do_something_else;
  3,4  : do_something_different;
  else : do_something_weird; 
}

तो कोई और अधिक विराम (आसान भूलना) और अल्पविराम-अलग-अलग मूल्यों की संभावना।

Question 15

C # में ईवेंट, जहां आपको श्रोताओं के लिए स्पष्ट रूप से जांच करनी है। घटनाओं के साथ बात नहीं थी, जो भी वहाँ हो प्रसारण करने के लिए? भले ही कोई भी क्यों न हो?

Question 16

भयंकर (और ज्यादातर लोगों के लिए काफी अदृश्य) हे (एन ^ 2) नेस्ट / पुनरावर्ती के व्यवहार iterators ।

मुझे इस बात का बहुत मलाल है कि वे इसके बारे में जानते हैं, जानते हैं कि इसे कैसे ठीक करना है लेकिन इसे योग्यता के समावेश के लिए पर्याप्त प्राथमिकता के रूप में नहीं देखा जाता है।

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

"यील्ड फॉरचेक" की सुंदरता यह है कि सरल, आसान सिंटैक्स सही, कलाकार कोड को प्रोत्साहित करता है " सफलता का पिटारा "है, जो मुझे लगता है कि उन्हें प्लेटफ़ॉर्म की दीर्घकालिक सफलता के लिए नई सुविधाओं को जोड़ने से पहले आकांक्षा करनी चाहिए।

Question 17

कुछ वर्ग इंटरफेस को लागू करते हैं, लेकिन वे उस इंटरफ़ेस के कई तरीकों को लागू नहीं करते हैं, उदाहरण के लिए ऐरे को लागू करता है लेकिन 9 में से 4 तरीके NotSupportedException http://msdn.microsoft.com/en-us/library/system/array_members फेंक देते हैं .aspx

Question 18

स्थैतिक सदस्य और इंटरफेस में नेस्टेड प्रकार।

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

Question 19

घटनाओं की बहुत खतरनाक डिफ़ॉल्ट प्रकृति। तथ्य यह है कि आप किसी ईवेंट को कॉल कर सकते हैं और ग्राहकों को हटाए जाने के कारण असंगत स्थिति में हो सकते हैं। विषय पर अधिक पढ़ने के लिए जॉन स्कीट और एरिक लिपर्ट के उत्कृष्ट लेख देखें ।

Question 20

null हर जगह।
const कहीं भी नहीं।
एपीआई असंगत हैं, उदाहरण के लिए एक सरणी रिटर्न म्यूट कर रहे हैं, voidलेकिन StringBufferरिटर्न एक ही उत्परिवर्तित करने के लिए संलग्न StringBuffer।
संग्रह इंटरफेस अपरिवर्तनीय डेटा संरचनाओं के साथ असंगत हैं, उदाहरण के लिए Add में System.Collections.Generic.IList<_>एक परिणाम नहीं लौटा सकता।
कोई संरचनात्मक टाइपिंग नहीं है ताकि आप लिखें System.Windows.Media.Effects.SamplingMode.Bilinear सिर्फ बजाय Bilinear।
परिवर्तनशील IEnumeratorजब यह अपरिवर्तनीय होना चाहिए तब कक्षाओं द्वारा लागू किया जाने वाला इंटरफ़ेस struct।
समानता और तुलना एक मेस हैं: आप मिल गया है System.IComparableऔर Equalsलेकिन फिर आप भी मिल गया है System.IComparable<_>, System.IEquatable, System.Collections.IComparer, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.Collections.Generic.IComparerऔर System.Collections.Generic.IEqualityComparer।
ट्यूपल्स को संरचित होना चाहिए लेकिन संरचनाएं अनावश्यक रूप से पूंछ कॉल उन्मूलन को रोकती हैं, इसलिए सबसे आम और मौलिक डेटा प्रकारों में से एक अनावश्यक रूप से आवंटित करेगा और स्केलेबल समानता को नष्ट करेगा।

Question 21

0 चांदनी को एनम

एनम की ख़ासियत: http://blogs.msdn.com/abhinaba/archive/2007/01/09/more-peculiarites-of-enum.aspx

जैसा कि इस अच्छे उदाहरण से स्पष्ट होता है: http://plus.kaist.ac.kr/~shoh/postgresql/Npgsql/apidocs/Npgsql.NpgsqlParameterColmetion.Add_overload_3.html

मेरा सुझाव है, "@" साइन को अच्छे उपयोग के लिए रखें:

के बजाय:

अगर ((myVar और MyEnumName.ColorRed)! = 0)

इसे इस्तेमाल करो:

अगर ((myVar और MyEnumName.ColorRed)! = @ 0)

Question 22

पहले से ही दूसरों द्वारा किए गए अच्छे बिंदुओं की लंबी सूची में जोड़ने के लिए:

DateTime.Now == DateTime.Now ज्यादातर मामलों में, लेकिन सभी मामलों में नहीं।
Stringजो अपरिवर्तनीय है उसके पास निर्माण और हेरफेर के लिए विकल्पों का एक गुच्छा है, लेकिन StringBuilder(जो कि परिवर्तनशील है) नहीं करता है।
Monitor.Enterऔर Monitor.Exitउदाहरण के तरीके होने चाहिए थे, इसलिए लॉकिंग के लिए एक विशिष्ट वस्तु को नया करने के बजाय, आप उस पर नया Monitorऔर लॉक कर सकते थे ।
विध्वंसक का नाम कभी भी विध्वंसक नहीं होना चाहिए था। ECMA कल्पना उन्हें अंतिम रूप से बुलाती है, जो C ++ भीड़ के लिए बहुत कम भ्रमित है, लेकिन भाषा विनिर्देश अभी भी उन्हें अवरोधक के रूप में संदर्भित करता है।

Question 23

जिस तरह से हम गुणों का उपयोग करते हैं वह मुझे कभी-कभी परेशान करता है। मैं उन्हें जावा के getFoo () और setFoo () विधियों के बराबर के रूप में सोचना पसंद करता हूं। लेकिन वे नहीं हैं।

यदि संपत्ति उपयोग दिशानिर्देश कहते हैं कि संपत्तियों को किसी भी क्रम में सेट किया जा सकता है तो क्रमबद्धता काम कर सकती है, तो वे सेटर-टाइम सत्यापन के लिए बेकार हैं। यदि आप एक ऐसी पृष्ठभूमि से आते हैं जहाँ आप किसी वस्तु को कभी भी अमान्य स्थिति में जाने से रोकना पसंद करते हैं, तो गुण आपके समाधान नहीं हैं। कभी-कभी मैं यह देखने में विफल रहता हूं कि वे सार्वजनिक सदस्यों की तुलना में कैसे बेहतर हैं, क्योंकि हम इतने सीमित हैं कि हम किस प्रकार की चीजों में हैं को गुणों में करने वाले हैं।

उस अंत तक, मैं हमेशा कामना करता हूं (यह ज्यादातर यहां जोर से सोच रहा है, मैं बस इस तरह की कामना करता हूं कि मैं कुछ ऐसा कर सकूं) कि मैं किसी तरह संपत्ति के सिंटैक्स का विस्तार कर सकूं। कुछ इस तरह की कल्पना करें:


private string password;

public string Password
{
    // Called when being set by a deserializer or a persistence
    // framework
    deserialize
    {
       // I could put some backward-compat hacks in here. Like
       // weak passwords are grandfathered in without blowing up
       this.password = value;
    }
    get
    {
       if (Thread.CurrentPrincipal.IsInRole("Administrator"))
       {
           return this.password;
       }
       else
       {
           throw new PermissionException();
       }
    }
    set
    {
       if (MeetsPasswordRequirements(value))
       {
           throw new BlahException();
       }
       this.password = value;
    }
    serialize
    {
        return this.password;
    }
}

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

Question 24

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

public class MyMixin<T> : T
{
    // etc...
}

उदाहरण के लिए एक स्ट्रिंग का विस्तार करने के लिए इसका उपयोग इस तरह किया जा सकता है:

var newMixin = new MyMixin<string>();

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

शेख़ी के लिए खेद :-)

Question 25

Microsoft फ्रेमवर्क में स्पष्ट बग्स को ठीक नहीं करेगा और हुक प्रदान नहीं करेगा ताकि अंतिम उपयोगकर्ता उन्हें ठीक कर सकें।

इसके अलावा, रनटाइम के दौरान बाइनरी-पैच .NET निष्पादक का कोई तरीका नहीं है और नेट लाइब्रेरीज़ (लोड कॉल को इंटरसेप्ट करने के लिए) को बाइनरी पैच किए बिना .NET फ्रेमवर्क लाइब्रेरी के निजी संस्करणों को निर्दिष्ट करने का कोई तरीका नहीं है, और ILDASM पुनर्वितरण योग्य नहीं है - मैं इसे स्वचालित नहीं कर सकता वैसे भी पैच।

Question 26

अशक्त चर पर एक विस्तार विधि को लागू करने में सक्षम होना चाहिए

ऑब्जेक्ट ए = अशक्त; a.MyExtMethod (); // यह कॉल करने योग्य है, मान लें कि उसने कहीं MyExtMethod को परिभाषित किया है

यह आसान हो सकता है लेकिन यह अशक्त संदर्भ अपवाद विषयों पर अस्पष्ट है।
एक नामकरण 'दोष'। System.configuration.dll में "कॉन्फ़िगरेशन" का 'C' कैपिटल में होना चाहिए।
उपवाद सम्भालना। अपवाद को जावा में जबरन पकड़ा या फेंक दिया जाना चाहिए, संकलनकर्ता को संकलन समय पर इसकी जांच करनी चाहिए। उपयोगकर्ताओं को लक्ष्य आह्वान के भीतर अपवाद जानकारी के लिए टिप्पणियों पर भरोसा नहीं करना चाहिए।

Question 27

.Parameters.Add () फ्रेमवर्क के V1 में SqlCommand पर विधि बुरी तरह से डिजाइन की गई थी - ओवरलोड में से एक मूल रूप से काम नहीं करेगा यदि आप 0 के मान (int) के साथ एक पैरामीटर में पास हुए - तो उन्हें बनाने के लिए नेतृत्व किया .Parameters.AddWithValue () SqlCommand वर्ग पर विधि।

Question 28

का कोई सबसेट नहीं है ICollection<T>और IList<T>; कम से कम, एक सहसंयोजक रीड-ओनली कलेक्शन इंटरफेस IListSource<out T>(एन्यूमरेटर, इंडेक्सर और काउंट के साथ) बेहद उपयोगी होता।
.NET कमजोर प्रतिनिधियों का समर्थन नहीं करता है । वर्कअराउड सबसे अच्छा अनाड़ी हैं, और आंशिक पक्ष में श्रोता-साइड वर्कआर्डर्स असंभव हैं (ReflectionPermission की आवश्यकता है)।
सामान्य इंटरफ़ेस एकीकरण तब भी निषिद्ध है जब यह समझ में आता है और कोई समस्या पैदा नहीं करता है।
C ++ के विपरीत, सहसंयोजक वापसी प्रकार .NET में की अनुमति नहीं है
समानता के लिए दो मूल्य प्रकारों को बिटवाइज़-तुलना करना संभव नहीं है। एक कार्यात्मक " लगातार " डेटा संरचना में, मैं लिख रहा थाTransform(Sequence<T>, Func<T,T>) फ़ंक्शन जिसे यह निर्धारित करने की आवश्यकता थी कि फ़ंक्शन समान मान या अलग मान लौटाता है या नहीं। यदि फ़ंक्शन अपने अधिकांश तर्कों को संशोधित नहीं करता है, तो आउटपुट अनुक्रम इनपुट अनुक्रम से कुछ / सभी मेमोरी साझा कर सकता है। किसी भी मूल्य प्रकार टी की तुलना करने की क्षमता के बिना, एक बहुत धीमी तुलना का उपयोग किया जाना चाहिए, जो प्रदर्शन को जबरदस्त चोट पहुंचाता है।
.NET एक तदर्थ तरीके से तदर्थ इंटरफेस (जैसे गो या रस्ट में पेश किए गए) का समर्थन करने में सक्षम नहीं लगता है। इस तरह के इंटरफेस ने आपको List<T>एक काल्पनिक IListSource<U>(जहां टी: यू) के लिए कास्ट करने की अनुमति दी होगी, भले ही वर्ग उस इंटरफ़ेस को स्पष्ट रूप से लागू नहीं करता है। इस कार्यक्षमता की आपूर्ति करने के लिए कम से कम तीन अलग-अलग पुस्तकालय (स्वतंत्र रूप से लिखे गए) हैं, प्रदर्शन की कमियों के साथ, निश्चित रूप से - यदि एक सही समाधान संभव था, तो इसे .NET में दोष कहना उचित नहीं होगा)।
अन्य प्रदर्शन मुद्दे: IEnumerator प्रति पुनरावृत्ति दो इंटरफ़ेस कॉल की आवश्यकता है। सादा विधि संकेत (इंटप्रा-आकार के खुले प्रतिनिधि) या मूल्य-टाइप किए गए प्रतिनिधि (इंटप्रे * 2) संभव नहीं हैं। निश्चित आकार के सरणियों (मनमाने प्रकार के टी) को कक्षाओं के अंदर एम्बेड नहीं किया जा सकता है। कोई नहीं है WeakReference<T>(आप आसानी से अपना लिख सकते हैं, लेकिन यह आंतरिक रूप से कलाकारों का उपयोग करेगा।)
तथ्य यह है कि समान प्रतिनिधि प्रकार असंगत माना जाता है (कोई अंतर्निहित रूपांतरण) (जैसे कुछ अवसरों पर मेरे लिए एक बाधा कर दिया गया है Predicate<T>बनाम Func<T,bool>)। मैं अक्सर चाहता हूं कि हम घटकों के बीच ढीले युग्मन को प्राप्त करने के लिए इंटरफेस और प्रतिनिधियों के लिए संरचनात्मक टाइपिंग कर सकते हैं , क्योंकि .NET में स्वतंत्र DLL में कक्षाओं के लिए समान इंटरफ़ेस लागू करने के लिए यह पर्याप्त नहीं है - उन्हें एक तिहाई के लिए एक सामान्य संदर्भ भी साझा करना होगा DLL जो इंटरफ़ेस को परिभाषित करता है।
DBNull.Valueमौजूद है, भले ही nullएक ही उद्देश्य समान रूप से अच्छी तरह से सेवा की है।
सी # में कोई नहीं है = = ऑपरेटर; आप अवश्य लिखें variable = variable ?? value। वास्तव में, C # में कुछ स्थान हैं, जिनमें अनावश्यक रूप से समरूपता की कमी है। उदाहरण के लिए आप if (x) y(); else z();(ब्रेसिज़ के बिना) लिख सकते हैं, लेकिन आप नहीं लिख सकते try y(); finally z();।
एक धागा बनाते समय, बच्चे के धागे को मूल धागा से थ्रेड-स्थानीय मान विरासत में लेने के लिए असंभव है। न केवल बीसीएल इस का समर्थन नहीं करता है, लेकिन आप इसे स्वयं लागू नहीं कर सकते हैं जब तक कि आप मैन्युअल रूप से सभी धागे नहीं बनाते हैं; भले ही कोई थ्रेड-निर्माण ईवेंट था, .NET आपको किसी दिए गए थ्रेड के "माता-पिता" या "बच्चे" नहीं बता सकता है ।
तथ्य यह है कि विभिन्न डेटा प्रकारों के लिए दो अलग-अलग लंबाई की विशेषताएं हैं, "लंबाई" और "गणना", एक मामूली उपद्रव है।
मैं हमेशा के लिए WPF ... और WCF (हालांकि कुछ परिदृश्यों के लिए काफी उपयोगी) के खराब डिजाइन के बारे में आगे बढ़ सकता है। सामान्य तौर पर, बीसीएल के कई नए पुस्तकालयों में ब्लोटनेस, अनइंस्टिट्यूट, और सीमित प्रलेखन मुझे उनका उपयोग करने के लिए अनिच्छुक बनाता है। बहुत सारे नए सामान अधिक सरल, छोटे, उपयोग करने में आसान और समझने में आसान, अधिक शिथिल युग्मित, बेहतर-प्रलेखित, अधिक उपयोग के मामलों के लिए लागू, तेज और / या अधिक दृढ़ता से टाइप किए जा सकते थे।
मुझे अक्सर संपत्ति पाने वालों और बसने वालों के बीच अनावश्यक कपलिंग द्वारा काट लिया गया है: एक व्युत्पन्न वर्ग या व्युत्पन्न इंटरफ़ेस में, आप बस एक सेटर नहीं जोड़ सकते जब आधार वर्ग या आधार इंटरफ़ेस में केवल एक गेट्टर होता है; यदि आप एक गॉटर को ओवरराइड करते हैं तो आपको एक सेटर को परिभाषित करने की अनुमति नहीं है; और आप सेटर को आभासी के रूप में परिभाषित नहीं कर सकते हैं लेकिन गैर-वर्चुअल के रूप में।

Question 29

एक बात है कि मुझे 1.x में बंद टिक का उपयोग करते समय था System.Xml.XmlValidatingReader, ValidationEventHandlerके ValidationEventArgsखुलासा नहीं करता अंतर्निहित XmlSchemaException(आंतरिक चिह्नित), जो की तरह सभी उपयोगी जानकारी है linenumberऔर position। इसके बजाय आप संदेश स्ट्रिंग संपत्ति से बाहर पार्स करने के लिए या इसे खोदने के लिए प्रतिबिंब का उपयोग करने की उम्मीद कर रहे हैं। इतना अच्छा नहीं है जब आप अंतिम उपयोगकर्ता के लिए एक अधिक संचित त्रुटि वापस करना चाहते हैं।

Question 30

यह पसंद नहीं है कि आप एक और एनम में एक एनम के मूल्यों का उपयोग नहीं कर सकते हैं, उदाहरण के लिए:

    enum Colors { white, blue, green, red, black, yellow }

    enum SpecialColors { Colors.blue, Colors.red, Colors.Yellow }

Question 31

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

MSDN से:

var का उपयोग केवल तब किया जा सकता है जब एक स्थानीय चर घोषित किया जाता है और एक ही कथन में आरम्भ किया जाता है; चर को शून्य, या विधि समूह या अनाम फ़ंक्शन के लिए प्रारंभ नहीं किया जा सकता है।
var का उपयोग फ़ील्ड स्कोप पर फ़ील्ड में नहीं किया जा सकता है।
Var का उपयोग करके घोषित चर का उपयोग इनिशियलाइज़ेशन एक्सप्रेशन में नहीं किया जा सकता है। दूसरे शब्दों में, यह अभिव्यक्ति कानूनी है: int i = (i = 20); लेकिन यह अभिव्यक्ति एक संकलन-समय त्रुटि पैदा करती है: var i = (i = 20);
एकाधिक निहित-टाइप किए गए चर को एक ही कथन में प्रारंभ नहीं किया जा सकता है।
यदि एक प्रकार का नाम var कार्यक्षेत्र में है, तो var कीवर्ड उस प्रकार के नाम को हल कर देगा और इसे अनुमानित रूप से टाइप किए गए स्थानीय चर घोषणा के हिस्से के रूप में नहीं माना जाएगा।

मुझे लगता है कि यह खराब क्रियान्वयन का कारण है कि वे इसे संस्करण कहते हैं, लेकिन यह एक संस्करण होने से एक लंबा रास्ता तय करता है। यह वास्तव में सिर्फ शॉर्टहैंड सिंटैक्स है जिसमें पूरी तरह से क्लास का नाम नहीं लिखा जाता है (जब लिंच के साथ प्रयोग किया जाता है)