सी # की छिपी विशेषताएं? [बन्द है]

1475

इस प्रश्न से निम्नलिखित जानने के बाद मेरे दिमाग में आया :

where T : struct

हम, सी # डेवलपर्स, सभी सी # की मूल बातें जानते हैं। मेरा मतलब है घोषणा, सशर्त, लूप, ऑपरेटर इत्यादि।

हम में से कुछ ने भी जेनरिक , अनाम प्रकार , लैम्ब्डा , LINQ , जैसे सामान में महारत हासिल की ...

लेकिन सी # की सबसे छिपी विशेषताएं या चालें क्या हैं जो कि सी # प्रशंसकों, नशेड़ी, विशेषज्ञों को भी मुश्किल से पता है?

यहाँ अब तक सामने आई विशेषताएं हैं:


कीवर्ड

गुण

वाक्य - विन्यास

भाषा सुविधाएं

दृश्य स्टूडियो सुविधाएँ

ढांचा

तरीके और गुण

सलाह & चाल

  • एंड्रियास एचआर निल्सन द्वारा घटना संचालकों के लिए अच्छी विधि
  • जॉन द्वारा अपरकेस की तुलना
  • गुमनाम प्रतिबिंबों तक पहुंच बिना dp द्वारा
  • विल द्वारा संग्रह गुणों को आलसी करने का एक त्वरित तरीका
  • जावास्क्रिप्ट की तरह अनाम इनलाइन-कार्य roosteronacid द्वारा

अन्य

c#  hidden-features 
— सेरहट ओजगेल
स्रोत

जवाबों:

752

यह सी # प्रति नहीं है, लेकिन मैंने किसी को भी नहीं देखा है जो वास्तव System.IO.Path.Combine()में उस सीमा तक उपयोग करता है जो उन्हें करना चाहिए। वास्तव में, संपूर्ण पथ वर्ग वास्तव में उपयोगी है, लेकिन कोई भी इसका उपयोग नहीं करता है!

मैं शर्त लगाने को तैयार हूं कि हर उत्पादन ऐप में निम्नलिखित कोड होते हैं, भले ही यह नहीं होना चाहिए:

string path = dir + "\\" + fileName;
— ageektrapped
स्रोत
584

लैम्ब्डा और प्रकार के अनुमानों को रेखांकित किया गया है। लैम्ब्डा के कई कथन हो सकते हैं और वे एक संगत प्रतिनिधि वस्तु के रूप में स्वचालित रूप से दोगुनी हो जाती हैं (बस सुनिश्चित करें कि हस्ताक्षर मैच हो):

Console.CancelKeyPress +=
    (sender, e) => {
        Console.WriteLine("CTRL+C detected!\n");
        e.Cancel = true;
    };

ध्यान दें कि मेरे पास नहीं है new CancellationEventHandlerऔर न ही मुझे इसके प्रकारों को निर्दिष्ट करना है senderऔर e, वे घटना से हीन हैं। यही कारण है कि यह पूरी तरह से लिखने के लिए कम बोझिल है delegate (blah blah)जिसके लिए आपको कई प्रकार के मापदंडों को भी निर्दिष्ट करना पड़ता है।

लैम्ब्डा को कुछ भी वापस करने की आवश्यकता नहीं है और इस तरह के संदर्भ में प्रकार का अनुमान बेहद शक्तिशाली है।

और BTW, आप हमेशा लैम्ब्डा को वापस ला सकते हैं जो लैम्बडा को कार्यात्मक प्रोग्रामिंग अर्थ में बनाते हैं। उदाहरण के लिए, यहाँ एक लैम्ब्डा है जो एक लैम्बडा बनाता है जो एक बटन को संभालता है। क्लिक करें घटना:

Func<int, int, EventHandler> makeHandler =
    (dx, dy) => (sender, e) => {
        var btn = (Button) sender;
        btn.Top += dy;
        btn.Left += dx;
    };

btnUp.Click += makeHandler(0, -1);
btnDown.Click += makeHandler(0, 1);
btnLeft.Click += makeHandler(-1, 0);
btnRight.Click += makeHandler(1, 0);

जंजीर पर ध्यान दें: (dx, dy) => (sender, e) =>

अब यही कारण है कि मुझे फंक्शनल प्रोग्रामिंग क्लास लेने में खुशी हो रही है :-)

सी में संकेत के अलावा, मुझे लगता है कि यह दूसरी बुनियादी बात है जिसे आपको सीखना चाहिए :-)

— चक्रित
स्रोत
528

से रिक Strahl :

आप चेन कर सकते हैं ?? ऑपरेटर ताकि आप अशक्त तुलना का एक गुच्छा कर सकें।

string result = value1 ?? value2 ?? value3 ?? String.Empty;
— रीफ़्स जेफ़
स्रोत
454

अलियासिड जेनरिक:

using ASimpleName = Dictionary<string, Dictionary<string, List<string>>>;

यह आपको ASimpleNameइसके बजाय उपयोग करने की अनुमति देता है Dictionary<string, Dictionary<string, List<string>>>।

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

— BlackTigerX
स्रोत
438

से सी # के माध्यम से CLR :

स्ट्रिंग्स को सामान्य करते समय, यह अत्यधिक अनुशंसा की जाती है कि आप ToLowerInvariant के बजाय ToUpperInvariant का उपयोग करें क्योंकि Microsoft ने अपरकेस तुलना करने के लिए कोड को अनुकूलित किया है ।

मुझे याद है कि एक समय मेरे सहकर्मी ने हमेशा तुलना करने से पहले अपरकेस को बदल दिया था। मुझे हमेशा आश्चर्य होता है कि वह ऐसा क्यों करता है क्योंकि मुझे लगता है कि पहले इसे लोअरकेस में बदलना अधिक "स्वाभाविक" है। किताब पढ़ने के बाद अब मुझे पता है क्यों।

— JFS
स्रोत
254
जब आप "स्ट्रिंग को ऊपरी मामले में परिवर्तित करते हैं" तो आप एक दूसरी अस्थायी स्ट्रिंग ऑब्जेक्ट बनाते हैं। मैंने सोचा था कि इस तरह की तुलना को प्राथमिकता नहीं दी गई थी, सबसे अच्छा तरीका यह था: String.Equals (stringA, stringB, StringComparison.CurrentCultureIgnoreCase) जो इस फेंकने वाले स्ट्रिंग को बिल्कुल नहीं बनाता है।
— एंथनी
32
ऊपरी केस स्ट्रिंग्स की तुलना करने पर आप किस प्रकार का अनुकूलन कर सकते हैं जो निचले केस स्ट्रिंग्स पर नहीं किया जा सकता है? मुझे समझ नहीं आता कि एक दूसरे की तुलना में अधिक इष्टतम क्यों होगा।
— परप्पा
36
लोअरकेस के बजाय अपरकेस में बदलने से कुछ संस्कृतियों में गलत व्यवहार को भी रोका जा सकता है। उदाहरण के लिए, तुर्की में, अधिक विवरण के लिए एक ही अपरकेस I. Google "तुर्की i" के लिए दो लोअरकेस i का नक्शा।
— नील
34
मैंने ToUpperInvariant vs ToLowerInvariant की बेंचमार्किंग की कोशिश की। मुझे .NET 2.0 या 3.5 के तहत उनके प्रदर्शन में कोई अंतर नहीं मिल रहा है। निश्चित रूप से ऐसा कुछ भी नहीं है जो दूसरे के ऊपर एक का उपयोग करते हुए "अत्यधिक अनुशंसित" का वारंट करता है।
— रासमस फेबर
19
ToUpperInvariant को पसंद किया जाता है क्योंकि यह सभी पात्रों को गोल-गोल बनाता है। Msdn.microsoft.com/en-us/library/bb386042.aspx देखें । तुलना के लिए, लिखें"a".Equals("A", StringComparison.OrdinalIgnoreCase)
— SLAKs
408

मेरी पसंदीदा चाल मेरे लिए स्वचालित रूप से तुरंत संग्रह करने के लिए अशक्त मोटे ऑपरेटर और कोष्ठक का उपयोग कर रही है।

private IList<Foo> _foo;

public IList<Foo> ListOfFoo 
    { get { return _foo ?? (_foo = new List<Foo>()); } }
— विल
स्रोत
23
क्या आपको पढ़ना मुश्किल नहीं लगता?
— रीरी
72
इसके थोड़ा मुश्किल noo ... एर, अनुभवहीन के लिए पढ़ने के लिए। लेकिन इसकी कॉम्पैक्ट और इसमें दो पैटर्न और भाषा की विशेषताएं हैं जो प्रोग्रामर को जानना और समझना चाहिए। इसलिए, जबकि यह पहली बार में कठिन है, यह सीखने का एक कारण होने का लाभ प्रदान करता है।
38
आलसी तात्कालिकता कुछ हद तक अन्याय है क्योंकि यह वर्ग के आक्रमणकारियों के बारे में सोचने से बचने के लिए एक गरीब आदमी की पसंद है। इसमें समसामयिक मुद्दे भी हैं।
— जॉन लीडेग्रेन
17
मुझे हमेशा सूचित किया जाता है कि यह बुरा व्यवहार है, कि संपत्ति को कॉल करने के लिए ऐसा कुछ नहीं करना चाहिए। यदि आपके पास वहाँ पर एक सेट था और मूल्य को शून्य करने के लिए सेट किया गया था, तो यह आपके एपीआई का उपयोग करने वाले किसी व्यक्ति के लिए बहुत अजीब होगा।
— इयान
8
@ जोल को छोड़कर लिस्टऑफफ को शून्य पर सेट करना न तो वर्ग अनुबंध का हिस्सा है और न ही यह अच्छा अभ्यास है। इसलिए कोई सेटर नहीं है। यह भी क्यों ListOfFoo एक संग्रह लौटने के लिए और एक अशक्त कभी नहीं की गारंटी है। इसकी एक बहुत ही अजीब शिकायत है कि यदि आप दो बुरे काम करते हैं (एक सेटर बनाते हैं और एक संग्रह को शून्य करने के लिए सेट करते हैं) तो यह आपकी अपेक्षाओं को गलत करेगा। मैं या तो पाने में पर्यावरण (।) का सुझाव नहीं होगा। लेकिन इसका भी इस जवाब से कोई लेना-देना नहीं है।
315

अशक्त घटना संचालकों के लिए जाँच से बचें

घोषणा में घटनाओं के लिए एक खाली प्रतिनिधि जोड़ना, हमेशा भयानक होने से पहले इस घटना की जांच करने की आवश्यकता को दबा देना। उदाहरण:

public delegate void MyClickHandler(object sender, string myValue);
public event MyClickHandler Click = delegate {}; // add empty delegate!

आप ऐसा करते हैं

public void DoSomething()
{
    Click(this, "foo");
}

इसके अलावा

public void DoSomething()
{
    // Unnecessary!
    MyClickHandler click = Click;
    if (click != null) // Unnecessary! 
    {
        click(this, "foo");
    }
}

कृपया इस विषय पर एरिक लिपर्ट (और संभावित डाउनसाइड्स) से संबंधित इस चर्चा और इस ब्लॉग पोस्ट को देखें।

— andnil
स्रोत
87
मेरा मानना ​​है कि एक समस्या दिखाई देगी यदि आप इस तकनीक पर भरोसा करते हैं और फिर आपको कक्षा को क्रमबद्ध करना होगा। आप ईवेंट को समाप्त कर देंगे, और फिर डीसेरिएलाइज़ेशन पर आपको एक NullRefference मिल जाएगा। .... तो क्या कोई चीज़ करने के "पुराने तरीके" पर टिक सकता है। यह सुरक्षित है।
— श्रीरोकू
16
आप अभी भी अपने ईवेंट हैंडलर को अशक्त करने के लिए सेट कर सकते हैं, इसलिए आप अभी भी एक अशक्त संदर्भ प्राप्त कर सकते हैं, और आपके पास अभी भी रेस की स्थिति है।
— रॉबर्ट पॉलसन
64
एक त्वरित प्रोफ़ाइल परीक्षण से पता चलता है कि अशक्त परीक्षण के बिना डमी-सब्सक्राइब्ड ईवेंट हैंडलर शून्य टेस्ट के साथ बिना सदस्यता वाले ईवेंट हैंडलर के समय को 2x लेता है। बिना टेस्ट के मल्टीकास्ट ईवेंट हैंडलर, सिंगल टेस्ट के लिए लगभग 3.5x का समय लेता है।
— पी डैडी
54
यह हमेशा एक स्व-ग्राहक होने से एक अशक्त जांच की आवश्यकता से बचा जाता है। यहां तक ​​कि एक खाली घटना के रूप में यह ओवरहेड वहन करता है जिसे आप नहीं चाहते हैं। अगर कोई ग्राहक नहीं है तो आप इस घटना को बिल्कुल भी नहीं भड़काना चाहेंगे, हमेशा एक खाली डमी घटना को पहले फायर न करें। मैं इस बुरे कोड पर विचार करूंगा।
— कीथ
56
उपरोक्त टिप्पणियों में कारणों के लिए यह एक भयानक सुझाव है। यदि आपको अपना कोड "साफ" दिखना चाहिए, तो नल की जांच के लिए एक विस्तार विधि का उपयोग करें, फिर घटना को कॉल करें। संशोधित विशेषाधिकारों के साथ किसी को निश्चित रूप से इस उत्तर में विपक्ष जोड़ना चाहिए।
— ग्रेग
305

सब कुछ, प्लस

1) अंतर्निहित जेनरिक (केवल तरीकों पर और कक्षाओं पर क्यों नहीं?)

void GenericMethod<T>( T input ) { ... }

//Infer type, so
GenericMethod<int>(23); //You don't need the <>.
GenericMethod(23);      //Is enough.

2) एक पैरामीटर के साथ सरल लैम्ब्डा:

x => x.ToString() //simplify so many calls

3) गुमनाम प्रकार और शुरुआती:

//Duck-typed: works with any .Add method.
var colours = new Dictionary<string, string> {
    { "red", "#ff0000" },
    { "green", "#00ff00" },
    { "blue", "#0000ff" }
};

int[] arrayOfInt = { 1, 2, 3, 4, 5 };

और एक:

4) ऑटो के गुण अलग-अलग हो सकते हैं:

public int MyId { get; private set; }

मुझे याद दिलाने के लिए धन्यवाद @pzycoman:

5) नामस्थान उपनाम (ऐसा नहीं है कि आपको इस विशेष अंतर की आवश्यकता है):

using web = System.Web.UI.WebControls;
using win = System.Windows.Forms;

web::Control aWebControl = new web::Control();
win::Control aFormControl = new win::Control();
— कीथ
स्रोत
14
# 3 में आप Enumerable.Range (1,5) कर सकते हैं
— इकोस्टॉर्म
18
मुझे लगता है कि आप int [] संख्या = {1,2,3} के साथ सरणियों को शुरू करने में सक्षम हैं; चूँकि 1.0 :) को "नए" कीवर्ड की भी आवश्यकता नहीं है
— लुकास
13
मापदंडों के बिना लैम्ब्डा भी () => DoSomething ();
— पाब्लो रिल्टक
5
मैंने दोनों का उपयोग किया है; आंतरिक सेट; } और पाओ; संरक्षित सेट; }, इसलिए यह पैटर्न सुसंगत है।
— कीथ
7
@ किर्क ब्रॉडहर्स्ट - आप सही हैं - new web.Control()इस उदाहरण में भी काम करेंगे। ::वाक्य रचना बलों यह एक नाम स्थान उपनाम के रूप में उपसर्ग के इलाज के लिए है, तो आप एक वर्ग कहा जाता है हो सकता था webऔर web::Controlजबकि वाक्य रचना अभी भी काम होगा, web.Controlवाक्य रचना वर्ग या नाम स्थान की जाँच करने के लिए कि क्या पता नहीं होता। इस वजह से मैं हमेशा ::नाम स्थान उपनाम का उपयोग करते हैं।
— कीथ
286

मैं काफी समय से "जैसा" कीवर्ड नहीं जानता था।

MyClass myObject = (MyClass) obj;

बनाम

MyClass myObject = obj as MyClass;

अगर क्लास माई कास्ट अपवाद नहीं है, तो ओब्ज मायक्लास नहीं है, तो दूसरा वापस आ जाएगा।

— माइक स्टोन
स्रोत
42
हालांकि यह मत करो। बहुत से लोग इसका उपयोग करते प्रतीत होते हैं क्योंकि सिंटैक्स पसंद करते हैं भले ही वे (टोटाइप) x के शब्दार्थ चाहते हों।
— स्कॉट लैंगहम
4
मेरा मानना ​​है कि यह बेहतर प्रदर्शन प्रदान करता है। क्या आपने इसे प्रोफाइल किया है? (जाहिर है कि यह तब होता है जब कलाकार विफल हो जाता है ... लेकिन जब आप (MyClass) कास्ट का उपयोग करते हैं, तो विफलताएं असाधारण होती हैं .. और बेहद दुर्लभ (यदि वे बिल्कुल भी होती हैं), तो इससे कोई फर्क नहीं पड़ता।
— स्कॉट लैंगहम
7
यह केवल तभी अधिक बेहतर होता है जब सामान्य स्थिति कलाकारों की विफलता हो। अन्यथा डायरेक्ट कास्ट (प्रकार) ऑब्जेक्ट तेज है। हालांकि एक प्रत्यक्ष कलाकार के लिए एक अपवाद को फेंकने की तुलना में अधिक समय लगता है, हालांकि यह अशक्त है।
— स्पेंस
15
"के रूप में" के रूप में "कीवर्ड ..." है "कीवर्ड की समान पंक्तियों के साथ ही उपयोगी है।
— dkpatt 7:09
28
आप इसका दुरुपयोग कर सकते हैं और एक NullReferenceException को अपनी सड़क पर बाद में ले सकते हैं जब आप पहले InvalidCastException हो सकते थे।
— आंद्रेई रोनेया
262

दो चीजें मुझे पसंद हैं, वे हैं स्वचालित गुण ताकि आप अपने कोड को और भी नीचे गिरा सकें:

private string _name;
public string Name
{
    get
    {
        return _name;
    }
    set
    {
        _name = value;
    }
}

हो जाता है

public string Name { get; set;}

इसके अलावा वस्तु आरंभीकरण:

Employee emp = new Employee();
emp.Name = "John Smith";
emp.StartDate = DateTime.Now();

हो जाता है

Employee emp = new Employee {Name="John Smith", StartDate=DateTime.Now()}
— lomaxx
स्रोत
6
क्या यह ध्यान दिया जाना चाहिए कि स्वचालित गुण केवल C # 3.0 हैं?
— जेरेड अपडेटेड
21
स्वचालित गुणों को 3.0 संकलक के साथ पेश किया गया था। लेकिन चूंकि संकलक को 2.0 कोड आउटपुट करने के लिए सेट किया जा सकता है, वे ठीक काम करते हैं। बस पुराने संकलक में स्वचालित गुणों के साथ 2.0 कोड संकलित करने का प्रयास न करें!
— जोशुआ शैनन
74
कुछ लोगों को यह एहसास नहीं होता है कि मिल और सेट की अलग-अलग पहुंच हो सकती है, जैसे: सार्वजनिक स्ट्रिंग नाम {get; निजी सेट;}
— नादेर शिराज़ी
7
केवल स्वचालित गुणों के साथ समस्या यह है कि डिफ़ॉल्ट आरंभिक मूल्य प्रदान करना संभव नहीं लगता है।
— स्टीन Steस्मुल
7
@ हंस: नहीं यह नहीं है। उस पृष्ठ से: एक DefaultValueAttribute सदस्य को विशेषता के मान के साथ स्वचालित रूप से आरंभ करने का कारण नहीं होगा। आपको अपने कोड में प्रारंभिक मूल्य निर्धारित करना होगा। [DefaultValue]डिज़ाइनर के लिए उपयोग किया जाता है इसलिए यह जानता है कि किसी संपत्ति को बोल्ड में दिखाना है (मतलब गैर-डिफ़ॉल्ट)।
— रोजर लिप्सकॉम्ब
255

सामान्य प्रकारों में 'डिफ़ॉल्ट' कीवर्ड:

T t = default(T);

एक 'अशक्त' में परिणाम यदि T एक संदर्भ प्रकार है, और 0 यदि यह एक इंट, झूठा है यदि यह एक बूलियन है, तो वगैरह।

— एरिक मिंकस
स्रोत
4
प्लस: टाइप? Nullable <प्रकार> के लिए एक शॉर्टकट के रूप में। default (int) == 0, लेकिन default (int?) == null
— सूर्यास्त
221

@ स्ट्रिंग में किसी भी भागने वाले पात्रों को अनदेखा करने के लिए कंपाइलर को बताता है।

बस इस एक को स्पष्ट करना चाहता था ... यह इसे भागने वाले पात्रों की अनदेखी करने के लिए नहीं कहता है, यह वास्तव में संकलक को स्ट्रिंग को शाब्दिक रूप से व्याख्या करने के लिए कहता है।

यदि आपके पास है 

string s = @"cat
             dog
             fish"

यह वास्तव में प्रिंट होगा (ध्यान दें कि इसमें इंडेंटेशन के लिए इस्तेमाल किया जाने वाला व्हाट्सएप भी शामिल है):

cat
             dog
             fish
— लोमैक्स
स्रोत
स्ट्रिंग में वे सभी स्थान शामिल नहीं होंगे जो आपने इंडेंटेशन के लिए उपयोग किए थे?
— एंडी
18
हां इसे वर्बटीम स्ट्रिंग कहा जाता है।
— जोन वैज
4
यह स्पष्ट होगा कि यदि आउटपुट उन स्थानों को दिखाता है जो प्रिंट आउट होंगे। अभी तो ऐसा लगता है जैसे नई लाइनों के अक्षर छपते हैं लेकिन रिक्त स्थान को नजरअंदाज कर दिया जाता है।
— aleemb
नियमित अभिव्यक्ति और लंबे एसक्यूएल प्रश्नों से बचने के लिए बहुत उपयोगी है।
— as999999
यह भी नक्शे {{के लिए {और }}करने के लिए }इसके लिए उपयोगी बनाने string.Format()।
— फेर्रुकियो
220

मुझे लगता है कि C # (.NET 3.5) के सबसे कम-प्रशंसित और कम-ज्ञात विशेषताओं में से एक अभिव्यक्ति पेड़ हैं , खासकर जब जेनरिक और लैम्ब्डा के साथ संयुक्त। यह एपीआई निर्माण के लिए एक दृष्टिकोण है जो NInject और Moq जैसे नए पुस्तकालयों का उपयोग कर रहे हैं।

उदाहरण के लिए, मान लें कि मैं एपीआई के साथ एक विधि पंजीकृत करना चाहता हूं और उस एपीआई को विधि नाम प्राप्त करने की आवश्यकता है

इस वर्ग को देखते हुए:

public class MyClass
{
     public void SomeMethod() { /* Do Something */ }
}

इससे पहले, डेवलपर्स को स्ट्रिंग्स और प्रकारों के साथ ऐसा करते देखना बहुत आम था (या कुछ और काफी हद तक स्ट्रिंग आधारित):

RegisterMethod(typeof(MyClass), "SomeMethod");

ठीक है, कि मजबूत टाइपिंग की कमी के कारण बेकार है। क्या होगा अगर मैं "SomeMethod" का नाम बदलूं? अब, 3.5 में, मैं इसे जोरदार ढंग से कर सकता हूं:

RegisterMethod<MyClass>(cl => cl.SomeMethod());

जिसमें RegisterMethod वर्ग Expression<Action<T>>इस तरह का उपयोग करता है:

void RegisterMethod<T>(Expression<Action<T>> action) where T : class
{
    var expression = (action.Body as MethodCallExpression);

    if (expression != null)
    {
        // TODO: Register method
        Console.WriteLine(expression.Method.Name);
    }
}

यह एक बड़ा कारण है कि मैं अभी लम्बेदा और अभिव्यक्ति पेड़ से प्यार कर रहा हूं।

— जेसन ओल्सन
स्रोत
3
मैं एक प्रतिबिंब उपयोगिता वर्ग कि FieldInfo, PropertyInfo, आदि के साथ ही करता है ...
— Olmo
हाँ, यह बहुत अच्छा है। मैं EditValue(someEmployee, e => e.FirstName);अपने व्यावसायिक तर्क की तरह कोड लिखने के लिए इस तरह के तरीकों का उपयोग करने में सक्षम था और यह स्वचालित रूप से उस संपत्ति को संपादित करने के लिए एक ViewModel और दृश्य के लिए सभी प्लंबिंग तर्क उत्पन्न करता है (इसलिए, "प्रथम नाम" पाठ के साथ एक लेबल और एक पाठ बॉक्स के साथ एक बंधन जो उपयोगकर्ता के नाम को संपादित करने पर फर्स्टनाम प्रॉपर्टी के सेटर को कॉल करता है, और गेटर का उपयोग करके व्यू को अपडेट करता है)। यह C # में अधिकांश नए आंतरिक DSLs के लिए आधार प्रतीत होता है।
— स्कॉट व्हिटलॉक
4
मुझे लगता है कि ये इतने कम नहीं हैं जितना कम समझा जाता है।
— जस्टिन मॉर्गन
आपको एक विधि पंजीकृत करने की आवश्यकता क्यों है? मैंने पहले कभी इसका इस्तेमाल नहीं किया है - यह कहां और कब इस्तेमाल किया जाएगा?
— मूनकनाइट
209

" उपज " मेरे दिमाग में आएगी। [DefaultValue ()] जैसी कुछ विशेषताएँ भी मेरे पसंदीदा में से हैं।

" Var " कीवर्ड थोड़ा अधिक जाना जाता है, लेकिन इसका उपयोग आप .NET 2.0 अनुप्रयोगों में भी कर सकते हैं (जब तक आप .NET 3.5 कंपाइलर का उपयोग करते हैं और इसे आउटपुट 2.0 कोड पर सेट करते हैं) बहुत ज्ञात नहीं लगता है कुंआ।

संपादित करें: कोको, बाहर इशारा करने के लिए धन्यवाद ?? ऑपरेटर, यह वास्तव में उपयोगी है। चूँकि इसके लिए Google के लिए थोड़ा कठिन है (जैसा कि ?? केवल अनदेखा किया गया है), यहाँ उस ऑपरेटर के लिए MSDN प्रलेखन पृष्ठ है: ?? ऑपरेटर (C # संदर्भ)

— माइकल स्टम
स्रोत
14
डिफ़ॉल्ट मान का दस्तावेज़ीकरण कहता है कि यह वास्तव में संपत्ति का मूल्य निर्धारित नहीं कर रहा है। यह केवल विज़ुअलाइज़र और कोड जनरेटर के लिए एक सहायक है।
— बोरिस कॉल
2
DefaultValue के लिए: इस बीच, कुछ पुस्तकालय इसका उपयोग करते हैं। ASP.net MVC एक कंट्रोलर एक्शन के पैरामीटर पर DefaultValue का उपयोग करता है (जो कि गैर-अशक्त प्रकारों के लिए बहुत उपयोगी है)। जाहिर है, यह एक कोड जनरेटर है क्योंकि मूल्य संकलक द्वारा नहीं बल्कि एमवीसी के कोड द्वारा निर्धारित किया जाता है।
— माइकल Stum
6
नाम के लिए ?? ऑपरेटर "नल कोलेसिंग" ऑपरेटर है
— आर्मस्ट्रांगेस्ट
पैदावार मेरा पसंदीदा है, कोलेसस ऑपरेटर हालांकि ऊपर है। मुझे CAS, या असेंबली साइनिंग, मजबूत नामों, GAC के बारे में कुछ भी नहीं दिखाई दे रहा है ... मुझे लगता है कि केवल CAS ही C # है ... लेकिन इतने सारे डेवलपर्स के पास सुरक्षा के बारे में कोई सुराग नहीं है।
— BrainSlugs83 21
198

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

double? num1 = null; 
double num2 = num1 ?? -100;

एक नल डबल, सेट संख्या 1 अशक्त करने के लिए, है, तो एक नियमित रूप से डबल, सेट NUM2 करने के लिए, संख्या 1 या -100 यदि संख्या 1 अशक्त था।

http://msdn.microsoft.com/en-us/library/1t3y8s4s(VS.80).aspx

अशक्त प्रकार के बारे में एक और बात:

DateTime? tmp = new DateTime();
tmp = null;
return tmp.ToString();

यह स्ट्रिंग है। खाली। चेक इस अधिक जानकारी के लिए लिंक

— ब्रैड बार्कर
स्रोत
1
दिनांक समय शून्य करने के लिए सेट नहीं किया जा सकता है।
— जेसन जैक्सन
2
तो फिर System.Int32 के लिए "int" सिर्फ C # सिंथैटिक शुगर है? वहाँ वास्तव में संकलक समर्थन Nullable प्रकार के आसपास बनाया गया है, उन्हें अशक्त करने के लिए सक्षम करने के लिए, उदाहरण के लिए (जो अकेले जेनेरिक संरचनाओं का उपयोग नहीं किया जा सकता है), और उन्हें अपने अंतर्निहित प्रकार के रूप में बॉक्सिंग।
— पी डैडी
4
@P डैडी - हाँ, int System.Int32 के लिए वाक्य रचना चीनी है। वे पूरी तरह से विनिमेय हैं, इंट की तरह? === इंट ३? === Nullable <Int32> === Nullable <int>
— cjk
6
@ck: हाँ, int System.Int32 के लिए एक उपनाम है, टी के रूप में? Nullable के लिए एक उपनाम है <टी> है, लेकिन यह नहीं है बस वाक्यात्मक चीनी। यह भाषा का एक परिभाषित हिस्सा है। उपनाम न केवल कोड को पढ़ने में आसान बनाते हैं, बल्कि हमारे मॉडल को भी बेहतर बनाते हैं। व्यक्त करने योग्य <डबल> डबल के रूप में? इस दृष्टिकोण को रेखांकित करता है कि इस प्रकार निहित मूल्य (या हो सकता है) एक डबल है, न कि कुछ सामान्य संरचना जो टाइप डबल पर त्वरित है। (जारी)
— पी डैडी
3
... किसी भी मामले में, यह तर्क उपनामों के बारे में नहीं था (यह सिर्फ एक गरीब सादृश्य था, मुझे लगता है), लेकिन यह अशक्त प्रकार-जो कुछ भी वाक्यविन्यास आप पसंद करते हैं - वास्तव में एक भाषा सुविधा है, न कि केवल जेनरिक का उत्पाद। आप asकेवल जेनरिक के साथ nullables की सभी कार्यक्षमता (null / असाइनमेंट की null, ऑपरेटर अग्रेषण, अंतर्निहित प्रकार की बॉक्सिंग या अशक्त, null coalescing और ऑपरेटरों के साथ संगतता ) की पुनरावृत्ति नहीं कर सकते । Nullable <T> अकेले अल्पविकसित और तारकीय से दूर है, लेकिन भाषा के हिस्से के रूप में अशक्त प्रकारों की अवधारणा किक गधा है।
— पी डैडी
193

यहां कुछ रोचक छिपे हुए C # फीचर्स हैं, जो अनिर्धारित C ​​# कीवर्ड के रूप में हैं:

__makeref

__reftype

__refvalue

__arglist

ये अनिर्धारित C ​​# कीवर्ड हैं (यहां तक ​​कि विज़ुअल स्टूडियो उन्हें पहचानता है!) जो कि जेनरिक से पहले अधिक कुशल बॉक्सिंग / अनबॉक्सिंग के लिए जोड़े गए थे। वे System.TypedReference संरचना के साथ समन्वय में काम करते हैं।

इसमें __arlist भी है, जिसका उपयोग चर लंबाई पैरामीटर सूचियों के लिए किया जाता है।

एक बात जो लोग ज्यादा नहीं जानते, वह है System.WeakReference - एक बहुत ही उपयोगी वर्ग जो किसी ऑब्जेक्ट का ट्रैक रखता है लेकिन फिर भी कचरा संग्रहकर्ता को इसे इकट्ठा करने की अनुमति देता है।

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

— जुडाह हिमांगो
स्रोत
2
पीटर ब्रोमबर्ग द्वारा अनिर्दिष्ट खोजशब्दों पर अधिक जानकारी । मैं अभी भी नहीं मिलता है अगर वहाँ कभी उन्हें उपयोग करने के लिए कारण हैं।
— हुबेज़ा
जेनरिक के आगमन के साथ @HuBeZa, __refType, __makeref और __refvalue के उपयोग के कई (किसी भी?) अच्छे कारण नहीं हैं। ये मुख्य रूप से .NET 2 में जेनेरिक से पहले बॉक्सिंग से बचने के लिए उपयोग किए गए थे
— जुडाह गेब्रियल हिमंगो
.NET 2 में जेनरिक की शुरूआत के साथ, इन खोजशब्दों का उपयोग करने का बहुत कम कारण है, क्योंकि उनका उद्देश्य मूल्य प्रकारों से निपटने के दौरान मुक्केबाजी से बचना था। HuBeZa द्वारा लिंक देखें, और यह भी देखें codeproject.com/Articles/38695/UnCommon-C-keywords-A-Look#ud
— यहूदा गेब्रियल हिमांगो
185

यूनियनों (C ++ ने मेमोरी मेमोरी साझा की) शुद्ध, सुरक्षित C # में

असुरक्षित मोड और पॉइंटर्स का सहारा लिए बिना, आप कक्षा के सदस्यों को क्लास / स्ट्रक्चर में मेमोरी स्पेस साझा कर सकते हैं। निम्नलिखित वर्ग को देखते हुए:

[StructLayout(LayoutKind.Explicit)]
public class A
{
    [FieldOffset(0)]
    public byte One;

    [FieldOffset(1)]
    public byte Two;

    [FieldOffset(2)]
    public byte Three;

    [FieldOffset(3)]
    public byte Four;

    [FieldOffset(0)]
    public int Int32;
}

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

    static void Main(string[] args)
    {
        A a = new A { Int32 = int.MaxValue };

        Console.WriteLine(a.Int32);
        Console.WriteLine("{0:X} {1:X} {2:X} {3:X}", a.One, a.Two, a.Three, a.Four);

        a.Four = 0;
        a.Three = 0;
        Console.WriteLine(a.Int32);
    }

इसे आउटपुट करता है:

2147483647
FF FF FF 7F
65535

केवल System.Runtime.InteropServices का उपयोग करके जोड़ें;

— ZeroBugBounce
स्रोत
7
जब आप संघ की घोषणाओं का उपयोग करते हुए सॉकेट्स पर विरासत ऐप के साथ संवाद कर रहे हों, @ जॉर्ज, काम करता है।
— 19
2
Int को कहने और ऑफ़सेट पर तैरने के लिए भी सार्थक है। यह है कि यदि आपको कभी-कभी फ़्लोटिंग पॉइंट नंबरों को बिट मास्क के रूप में हेरफेर करना है, तो आपको क्या चाहिए। खासकर यदि आप फ्लोटिंग पॉइंट नंबरों के बारे में नई चीजें सीखना चाहते हैं।
— जॉन लेडिग्रेन
2
इसके बारे में कष्टप्रद बात यह है कि यदि आप इसका उपयोग करने जा रहे हैं तो यह एक कंपाइलर है जो कंपाइलर आपको सभी फंक्शन को इनिट फंक्शन में सेट करने के लिए मजबूर करेगा। इसलिए यदि आपके पास: सार्वजनिक A (int int32) {Int32 = int32; } यह "फ़ील्ड 'एक को पूरी तरह से नियत करने से पहले कॉल करने वाले को वापस कर दिया जाना चाहिए" फेंक देगा, इसलिए आपको एक = दो = तीन = चार = 0 सेट करना होगा; भी।
— manixrock
2
ज्यादातर बाइनरी डेटा के साथ इसके उपयोग हैं। मैं एक int32 @ 0 के साथ एक "पिक्सेल" संरचना का उपयोग करता हूं, और चार घटकों @ 0, 1, 2 के लिए चार बाइट्स, और 3. जल्दी और आसानी से छवि डेटा में हेरफेर करने के लिए महान।
— स्नार्फ
57
चेतावनी: यह दृष्टिकोण एंडियननेस को ध्यान में नहीं रखता है। इसका मतलब है कि आपका C # कोड सभी मशीनों पर समान तरीके से नहीं चलेगा। छोटे-एंडियन सीपीयू (जो पहले कम से कम महत्वपूर्ण बाइट को स्टोर करते हैं) पर, दिखाए गए व्यवहार का उपयोग किया जाएगा। लेकिन बड़े-एंडियन सीपीयू पर, बाइट्स आपकी उम्मीद से उलट हो जाएगा। खबरदार कि आप इसे उत्पादन कोड में कैसे उपयोग करते हैं - आपका कोड कुछ मोबाइल उपकरणों और अन्य हार्डवेयर के लिए पोर्टेबल नहीं हो सकता है, और गैर-स्पष्ट तरीकों से टूट सकता है (उदाहरण के लिए एक ही प्रारूप में दो फाइलें अस्थिरता से लेकिन वास्तव में बाइट क्रम के साथ उलट)।
— रे बर्न्स
176

उन चर नामों के लिए @ का उपयोग करना जो कीवर्ड हैं।

var @object = new object();
var @string = "";
var @if = IpsoFacto();
— मार्क सिडेड
स्रोत
38
आप एक चर नाम के रूप में एक खोजशब्द का उपयोग क्यों करना चाहेंगे? मुझे लगता है कि यह कोड को कम पठनीय और अस्पष्ट बना देगा।
— जॉन
41
खैर, इसका कारण यह है कि सीएलआई को अन्य भाषाओं के साथ इंटरऑपरेबिलिटी की आवश्यकता होती है जो सदस्य नामों के रूप में सी # कीवर्ड का उपयोग कर सकते हैं
— मार्क सिडैड
69
यदि आप कभी भी asp.net MVC HTML सहायकों का उपयोग करना चाहते हैं और एक HTML वर्ग को परिभाषित करते हैं, तो आपको यह जानकर खुशी होगी कि आप @class का उपयोग कर सकते हैं, इसलिए इसे वर्ग कीवर्ड के रूप में मान्यता नहीं दी जाएगी
— बोरिस कॉलेंस
31
विस्तार के तरीकों के लिए महान। सार्वजनिक स्टेटिक शून्य DoSomething (यह बार @this, string foo) {...}
— जोनाथन C डिकिंसन
45
@ इज़होटकी: गलत। var a = 5; Console.WriteLine (@a); प्रिंट्स 5
— SLaks
168

यदि आप किसी भी अंत में ब्लॉक या फाइनल कॉल के बिना अपने प्रोग्राम से बाहर निकलना चाहते हैं, तो FailFast का उपयोग करें :

Environment.FailFast()
— जन बैनिस्टर
स्रोत
12
ध्यान दें कि यह विधि एक मेमोरी डंप भी बनाती है और विंडोज त्रुटि लॉग के लिए एक संदेश लिखती है।
— रिकएनजेड डिक्
1
यह ध्यान दिया जाना चाहिए कि इस पद्धति का उपयोग किए जाने पर कोई भी
— फ़ाइनल
1
संकेत के लिए +1, लेकिन यह C # नहीं है, यह .NET की BCL है।
— हाबिल
System.Diagnostics.Process.GetCurrentProcess ()। Kill () तेज है
— तोलघन अल्बराक
153

किसी विधि से अनाम प्रकार लौटना और बिना प्रतिबिंब के सदस्यों तक पहुँचना।

// Useful? probably not.
private void foo()
{
    var user = AnonCast(GetUserTuple(), new { Name = default(string), Badges = default(int) });
    Console.WriteLine("Name: {0} Badges: {1}", user.Name, user.Badges);
}

object GetUserTuple()
{
    return new { Name = "dp", Badges = 5 };
}    

// Using the magic of Type Inference...
static T AnonCast<T>(object obj, T t)
{
   return (T) obj;
}
— डेनिस फिलिप्स
स्रोत
42
यह वास्तव में आपको कुछ भी नहीं मिलता है। यह वास्तव में खतरनाक है। क्या होगा यदि GetUserTuple को कई प्रकार वापस करने के लिए संशोधित किया जाए? रन टाइम पर कास्ट फेल हो जाएगी। C # /। नेट के बारे में महान चीजों में से एक संकलन समय की जाँच है। केवल एक नए प्रकार का निर्माण करना बेहतर होगा।
— जेसन जैक्सन
9
@ जेसन मैंने कहा कि यह शायद उपयोगी नहीं है लेकिन यह आश्चर्यजनक है (और मुझे लगा कि छिपा हुआ है)।
— डेनिस फिलिप्स
31
शांत होने के दौरान, यह एक खराब डिजाइन विकल्प की तरह लगता है। आपने मूल रूप से दो स्थानों में अनाम प्रकार परिभाषित किया है। उस बिंदु पर, बस एक वास्तविक संरचना की घोषणा करें और सीधे इसका उपयोग करें।
— पॉल अलेक्जेंडर
6
@ समूह: इस तरह के सम्मेलन को ... संरचना कहा जाएगा?
— आर। मार्टिनो फर्नांडीस 11
2
इस ट्रिक को 'कास्ट बाय सैंपल' नाम दिया गया है और यह काम नहीं करेगा अगर वह विधि जो गुमनाम प्रकार से लौटे तो दूसरी असेंबली में स्थित है।
— desco
146

यहाँ नियमित भाव और फ़ाइल पथ के लिए एक उपयोगी है:

"c:\\program files\\oldway"
@"c:\program file\newway"

@ स्ट्रिंग में किसी भी भागने वाले पात्रों को अनदेखा करने के लिए कंपाइलर को बताता है।

— दर्शाता है
स्रोत
27
इसके अलावा, एक @ निरंतर अंदर की सुर्खियों को स्वीकार करता है। एक स्ट्रिंग पर एक बहुस्तरीय स्क्रिप्ट असाइन करते समय बिल्कुल सही।
— टॉर हौगेन
11
एक उद्धरण चिह्न से बचने के लिए भी मत भूलना उन्हें दूसरे शब्दों में दोहराएं। [कोड] var कैंडी = @ "मुझे पसंद है" "लाल" "कैंडी के डिब्बे।"; [/ कोड]
— डेव
5
मैं Path.Combine के साथ पथों का निर्माण करता हूं। मैं निश्चित रूप से regex के लिए @ का उपयोग करता हूं!
— डैन मैकक्लेन
6
@new किसी कीवर्ड के बजाय एक वैरिएबल भी है: @this, @int, @return, @interface ... so on :)
— IAbstract
यह कोई भी कहीं भी पास नहीं आता है: लेकिन सी # की सबसे छिपी हुई विशेषताएं या चालें क्या हैं, यहां तक ​​कि सी # प्रशंसक, व्यसनी, विशेषज्ञ भी नंगे जानते हैं?
— publicgk
141

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

public static DeepCopy(this IPrototype p) { ... }

बेशक, कुछ स्पष्टता बलिदान की जाती है। लेकिन यह काम करता है!

— दिमित्री नेस्टरुक को दर्शाता है
स्रोत
4
हाँ, मुझे लगता है कि यह विस्तार विधियों की वास्तविक शक्ति है। वे मूल रूप से इंटरफ़ेस विधियों के कार्यान्वयन के लिए अनुमति देते हैं।
— जॉन Bubriski
यह भी आसान है अगर आप NHibernate (या Castle ActiveRecord) का उपयोग कर रहे हैं और आपको अपने संग्रह के लिए इंटरफेस का उपयोग करना होगा। इस तरह आप संग्रह इंटरफेस को व्यवहार दे सकते हैं।
— रेयान लुंडी
कि मूल रूप से सभी LINQ तरीकों को रिकॉर्ड के लिए कैसे लागू किया जाता है।
— WCWedin
यहां एक लिंक दिया गया है, जो मैं ऊपर बताए गए तरीकों के बारे में बताता हूं, NHibernate या Castle ActiveRecord में कलेक्शन इंटरफेस के साथ एक्सटेंशन विधियों का उपयोग करके: devlicio.us/blogs/billy_mccafferty/archive/2008/09/03/ "
— Ryan Lundy
7
यदि केवल वे ही एक्सटेंशन संपत्तियों की अनुमति देते हैं !!!! मैं एक विस्तार विधि लिखने के लिए नफरत करता था, जो केवल पढ़ने के लिए संपत्ति के रूप में भीख
— जॉन गिब
130

यकीन नहीं है कि क्यों कोई भी Nullable <bool> का उपयोग करना चाहेगा। :-)

सच, गलत, FileNotFound ?

— माइकल स्टम
स्रोत
87
यदि किसी उपयोगकर्ता से किसी प्रश्न का उत्तर देने में हाँ की अपेक्षा की जाती है, तो उत्तर उपयुक्त होगा यदि प्रश्न का उत्तर नहीं दिया गया है
— उमर कोहेजी
22
अशक्त प्रकार एक डेटाबेस के साथ बातचीत के लिए आसान होते हैं जहां टेबल कॉलम अक्सर अशक्त होते हैं।
— tuinstoel
11
हां, नहीं, मेबी?
— दान ब्लेयर
21
— थ्रीस्टेट
8
एसक्यूएल में के रूप में: हाँ / नहीं / अज्ञात।
— एरिक्कलेन
116

यह एक "छिपा हुआ" नहीं है क्योंकि यह गलत है।

एल्गोरिदम "मैप", "कम", और "फिल्टर" पर बहुत ध्यान दिया जाता है। अधिकांश लोगों को यह एहसास नहीं है कि .NET 3.5 ने इन तीनों एल्गोरिदम को जोड़ा है, लेकिन इसने उन्हें बहुत SQL-ish नाम दिया है, इस तथ्य के आधार पर कि वे LINQ का हिस्सा हैं।

"मानचित्र" =>
एक रूप से दूसरे रूप में रूपांतरण डेटा चुनें

"कम" =>
एक ही परिणाम में मूल्यों को एकत्र करता है

"फ़िल्टर" => जहां
एक मापदंड के आधार पर डेटा फ़िल्टर करता है

LINQ का उपयोग करने की क्षमता संग्रह और इनसेटल्स को लेने के लिए उपयोग किए जाने वाले संग्रह पर इनलाइन काम करने की क्षमता अविश्वसनीय रूप से मूल्यवान हो सकती है। यह सीखने लायक है कि कैसे सभी LINQ एक्सटेंशन विधियां आपके कोड को बहुत अधिक कॉम्पैक्ट और बनाए रखने में मदद कर सकती हैं।

— ब्रैड विल्सन
स्रोत
1
चयन भी भिक्षुओं में "वापसी" फ़ंक्शन की तरह काम करता है। देखें stackoverflow.com/questions/9033/hidden-features-of-c#405088
— मार्क सिडेड
1
यदि आप SQLish सिंटैक्स का उपयोग करते हैं तो "चयन" का उपयोग करना आवश्यक है। यदि आप एक्सटेंशन विधि वाक्यविन्यास का उपयोग करते हैं - someCollection.Where (आइटम => आइटम.प्राइस> 5.99M) - चुनिंदा बयानों के उपयोग की आवश्यकता नहीं है।
— ब्रैड विल्सन
7
@ ब्रैड, वह (जहां) एक फिल्टर ऑपरेशन है। चयन के बिना मानचित्र संचालन करने का प्रयास करें ...
— Eloff
2
LINQ बड़ी बात है जो मेरी राय में C # की हुई है: stackoverflow.com/questions/2398818/…
— लेनिएल मैकाफेर्री
1
एग्रीगेट का सबसे छोटा हस्ताक्षर "कम" फ़ंक्शन है, एग्रीगेट का मध्य हस्ताक्षर बहुत अधिक शक्तिशाली "गुना" फ़ंक्शन है!
— ब्रेट विडमियर
115 
Environment.NewLine

प्रणाली के लिए स्वतंत्र newlines।

— एनटी।
स्रोत
10
इस बारे में कष्टप्रद बात यह है कि यह कॉम्पैक्ट ढांचे में शामिल नहीं है।
— स्ट्रोमेनेट
14
यह इंगित करने के लायक है कि यह एप्लिकेशन के होस्ट प्लेटफ़ॉर्म के लिए विशिष्ट है - इसलिए यदि आप किसी अन्य सिस्टम के लिए डेटा बनाना चाहते हैं, तो आपको उचित रूप से \ n या \ r \ n का उपयोग करना चाहिए।
— मेष
यह .NET की BCL का हिस्सा है, सी # की सुविधा नहीं है।
— हाबिल
111

यदि आप String.Format अभिव्यक्ति के अंदर घुंघराले कोष्ठक का उपयोग करने की कोशिश कर रहे हैं ...

int foo = 3;
string bar = "blind mice";
String.Format("{{I am in brackets!}} {0} {1}", foo, bar);
//Outputs "{I am in brackets!} 3 blind mice"
— पोर्टमैन
स्रोत
19
@Kyralessa: वास्तव में, हाँ, वे ब्रेसिज़ हैं, लेकिन "घुंघराले कोष्ठक" उनके लिए एक वैकल्पिक नाम है। [और ]वर्ग कोष्ठक हैं, और <और >कोण कोष्ठक हैं। En.wikipedia.org/wiki/ ब्रैकेट देखें ।
— icktoofay
4
तुम सही हो। लेकिन जब मैंने टिप्पणी की, तो उसने "घुंघराले" कोष्ठक नहीं कहा।
— रयान लूनी
2
इंगित करने के लिए बहुत अच्छा है। याद रखें कि मेरा पहला स्ट्रिंग.फॉर्मट कैसा दिखता था: स्ट्रिंग.फॉर्मैट ("{0} मैं घुंघराले ब्रैकेट में हूं {1} {2} {3}", "{", "}", 3, "अंधा चूहे"); एक बार जब मुझे पता चला कि ये {{और}} का उपयोग करके बच गए हैं, तो मैं बहुत खुश था :)
— Gertjan
Muahahahaa ... .Net में पहले से ही 3 साल के प्रोग्रामिंग और मुझे यह नहीं पता था। : डी
— अर्निस लैप्सा
"घुंघराले" कोष्ठकों से बचने के लिए अभिनय समान है ??
— प्रतीकात्मक
104
  1. ?? - coalescing संचालक
  2. उपयोग ( कथन / निर्देश ) - महान कीवर्ड जिसका उपयोग केवल कॉलिंग डिस्पोज से अधिक के लिए किया जा सकता है
  3. आसानी से उपयोग किया जाना चाहिए
  4. netmodules - बहुत बुरा है Visual Studio में कोई समर्थन नहीं है
— डॉक्टर जोन्स
स्रोत
6
का उपयोग करते हुए एक लंबे नाम स्थान को और अधिक सुविधाजनक स्ट्रिंग में बदलने के लिए भी उपयोग किया जा सकता है, अर्थात: ZipEncode = MyCompany.UtilityCode.Compression.Zip.Encoding का उपयोग करना; यहाँ और भी है: msdn.microsoft.com/en-us/library/sf0df423.aspx
— डेव आर।
2
यह वास्तव में एक ही बात नहीं है। डिस्पोज को बुलाते समय, आप उपयोग कथन का उपयोग कर सकते हैं, जब आप उपयोग कर रहे निर्देश का उपयोग कर रहे हैं।
— atयविन्दर स्कार
2
बस अगर आप # 1 का नाम चाहते हैं (जैसा कि आपने टर्नरी ऑपरेटर के साथ किया था), ?? को नल कोलेसिंग ऑपरेटर कहा जाता है।
— जे। स्टीन
4
@LucasAardvark: जैसा कि जे स्टीन ने उल्लेख किया है कि इसे अशक्त सहवर्ती ऑपरेटर कहा जाता है। उसके लिए खोजें!
— कोकोज
1
खोजने के लिए ?? ऑपरेटर Google पर प्रयास करें: google.com/search?q=c%23+%3F%3F+operator
— backslash17
103

@ ईडी, मैं इसे पोस्ट करने के बारे में थोड़ा अस्पष्ट हूं क्योंकि यह नाइटपैकिंग से थोड़ा अधिक है। हालाँकि, मैं आपके कोड नमूने में इंगित करूंगा:

MyClass c;
  if (obj is MyClass)
    c = obj as MyClass

यदि आप 'is' का उपयोग करने जा रहे हैं, तो 'as' का उपयोग करके सुरक्षित कास्ट का पालन क्यों करें? यदि आपको पता चला है कि ओब्ज वास्तव में MyClass है, तो एक दलदल-मानक कलाकार:

c = (MyClass)obj

... कभी असफल होने वाला नहीं है।

इसी तरह, आप बस कह सकते हैं:

MyClass c = obj as MyClass;
if(c != null)
{
   ...
}

मुझे यकीन नहीं है कि .NET की इनर्ड्स के बारे में पर्याप्त जानकारी है, लेकिन मेरी वृत्ति मुझे बताती है कि इससे अधिकतम दो प्रकार के कास्ट ऑपरेशंस को अधिकतम एक तक घटा दिया जाएगा। प्रसंस्करण बैंक के टूटने की शायद ही कोई संभावना है; व्यक्तिगत रूप से, मुझे लगता है कि बाद वाला रूप क्लीनर भी दिखता है।

— Dogmang
स्रोत
16
यदि कास्ट सटीक प्रकार के लिए है (जब "ए" के लिए "ए" डाली जाती है, तो इससे व्युत्पन्न नहीं होता है), स्ट्रेट कास्ट "के रूप में" की तुलना में ~ 3x फीस्टर है। जब एक व्युत्पन्न प्रकार ("ए" के लिए डाली जाती है जब ऑब्जेक्ट "बी" होता है, जो "ए" से निकलता है), तो सीधे कास्ट "के रूप में" की तुलना में 0.1x धीमी है। "है", फिर "जैसा" सिर्फ मूर्खतापूर्ण है।
— पी डैडी
2
नहीं, लेकिन आप "if ((c = obj as MyClass)! = Null)" लिख सकते हैं।
— डेव वान डेन आईंड
10
isऔर asउपयोगकर्ता कास्ट नहीं करेंगे। तो, उपरोक्त कोड isऑपरेटर से पूछ रहा है कि क्या obj MyClass से लिया गया है (या इसमें अंतर्निहित सिस्टम परिभाषित कास्ट है)। इसके अलावा, isविफल रहता है null। ये दोनों किनारे मामले आपके कोड के लिए महत्वपूर्ण हो सकते हैं। उदाहरण के लिए, आप लिखना चाह सकते हैं: if( obj == null || obj is MyClass ) c = (MyClass)obj; लेकिन यह कड़ाई से भिन्न है: try { c = (MyClass)obj; } catch { }चूंकि पूर्व कोई उपयोगकर्ता परिभाषित रूपांतरण नहीं करेगा, लेकिन बाद वाला होगा। nullचेक के बिना , पूर्व भी सेट नहीं होगा कि cकब objहै null।
— एडम लेटर
2
IL में, एक कलाकार एक CASTCLASS में जाता है, लेकिन एक ISINST निर्देश पर जाता है।
— जॉन गिब
5
मैं इस के लिए एक परीक्षण भाग गया, कास्टिंग IEnumerable<int>के लिए List<int>, और कास्टिंग object( new object()करने के लिए) IEnumerable<int>, बनाने के लिए यकीन है कि वहाँ कोई गलती कर रहे हैं: प्रत्यक्ष डाली: 5.43ns, है-> के रूप में कास्ट: कलाकारों के रूप में 6.75ns,: 5.69ns। फिर अमान्य कास्ट का परीक्षण: डायरेक्ट कास्ट: 3125000ns, कास्ट के रूप में: 5.41ns। निष्कर्ष: 1% कारक के बारे में चिंता करना बंद कर दें, और सुनिश्चित करें कि आप उपयोग करते हैं / जब डाली अमान्य हो सकती है, तो अपवाद (कारण भी अगर संभाला जाता है) कास्टिंग की तुलना में बहुत धीमा है, हम एक कारक 578000 धीमे के बारे में बात कर रहे हैं। याद रखें कि अंतिम भाग, बाकी कोई फर्क नहीं पड़ता (.Net FW 4.0, रिलीज़ बिल्ड)
— Aidiakapi
98

शायद एक उन्नत तकनीक नहीं है, लेकिन एक मैं हर समय देखता हूं जो मुझे पागल करता है:

if (x == 1)
{
   x = 2;
}
else
{
   x = 3;
}

संघनित किया जा सकता है:

x = (x==1) ? 2 : 3;
— Jasons
स्रोत
10
मेरे समूह में टर्नरी ऑपरेटर पर प्रतिबंध लगा दिया गया है। कुछ लोगों को यह पसंद नहीं है, हालांकि मुझे कभी समझ नहीं आया कि क्यों।
— जस्टिन आर।
13
मुझे लगता है क्योंकि वे वही चीजें नहीं हैं, एक ऑपरेटर होने के नाते एक बयान नहीं। मैं पहले दृष्टिकोण को खुद पसंद करता हूं। यह अधिक सुसंगत और आसानी से विस्तार योग्य है। ऑपरेटरों के बयान नहीं हो सकते हैं, इसलिए जिस मिनट आपको शरीर का विस्तार करना है, आपको उस टर्नरी ऑपरेटर को एक बयान में
— बदलना होगा
16
x ++ तक संघनित किया जा सकता है; ठीक है यह व्यर्थ है ^ ^
— फ्रांस्वा
5
@ गिलियूम: x के सभी मूल्यों के लिए खाता: x = 2 + System.Math.Min (1, System.Math.Abs ​​(x-1));
— मबेकिश
38
इसे वास्तव में "सशर्त ऑपरेटर" कहा जाता है - यह एक टर्नरी ऑपरेटर है क्योंकि इसमें तीन तर्क होते हैं। en.wikipedia.org/wiki/Conditional_operator
— Blorgbeard
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.