एक छोटे से कार्यक्रम में C # 3.0 में सब कुछ नया

सड़क पर मौसम बहुत अच्छा नहीं है, मैं कहीं नहीं गया, मैंने कुछ विकृत बनाने का फैसला किया, मैं वास्तव में चाहता था ... मैं नीचे एक छोटे कार्यक्रम का कोड प्रस्तुत करता हूं। उसे क्या दिलासा देना चाहिए? अपने आप को संकलित करें और परीक्षण करें ...



कर्म को कम करने वालों के लिए: पोस्ट पसंद नहीं है अन्य विषयों पर जाएं। वह एक निजी ब्लॉग पर हैं। आखिरकार, मैं टिप्पणी करने के लिए तैयार हूं, लेकिन मैं वर्चुअल नहीं बनाता हूं, इतना कठोर मत बनो ...







सिस्टम का उपयोग कर ;

System.Collections.Generic का उपयोग कर ;

System.Linq का उपयोग करना ;

System.Runtime.Remoting.Messaging का उपयोग कर ;



नेमस्पेस फ्रोज़िक

{

स्थिर वर्ग कार्यक्रम

{

सार्वजनिक स्थैतिक चार्ट फर्स्टचार् <TInput> ( यह TInput मान )

जहां TInput: वर्ग

{

वापसी मान। StString () [0];

}



स्थिर शून्य मुख्य ()

{

var तर्क = नई सूची < string > { "arg_0" , "temp_z" , "arg_1" , "arg_2" };



ऑब्जेक्ट लॉकर;



ताला (लॉकर = नई वस्तु ) ()

{

Console.WriteLine ( "प्रारंभ" );



(( फ़ंक < string >) () =>

{

ताला (लॉकर)

{

var परिणाम = string .Empty;



foreach ( स्ट्रिंग arg in

(तर्क में तर्क से

जहाँ argEntity.StartsWith ( "arg_" )

argEntity.Substring (4)) का चयन करें

{

Console.WriteLine (परिणाम + = arg.FirstChar < string > ());

}



वापसी परिणाम;

}

}))। BeginInvoke (

( प्रतिनिधि (IAsyncResult परिणाम) {

Console.WriteLine (

नई

{

लेनथ =

((फंक < string >) ((AsyncResult) परिणाम) ।AsyncDelegate)।

EndInvoke (परिणाम)। गति

} (कम);

})

नई वस्तु ()

);



Console.WriteLine ( "समाप्त" );



Console.ReadKey ();

}



Console.ReadKey ();

}

}

}



नीचे उन लोगों के लिए स्पष्टीकरण दिए गए हैं जो वाक्य रचना को नहीं समझते हैं





सिस्टम का उपयोग कर;

System.Collections.Generic का उपयोग कर;

System.Linq का उपयोग करना;

System.Runtime.Remoting.Messaging का उपयोग कर;



नेमस्पेस फ्रोज़िक

{

स्थिर वर्ग कार्यक्रम

{

// मेरे कार्यक्रम के विस्तार में सभी संदर्भ प्रकारों के लिए एक एक्सटेंशन बनाएं

// केवल स्ट्रिंग्स पर लागू किया जाएगा। मेरे पास केवल एक सामान्य एक्सटेंशन है

// अधिक भ्रमित होने के लिए।

// एक्सटेंशन कैसे काम करते हैं:

// विधियों को किसी भी मानक या गैर-मानक प्रकार में जोड़ा जा सकता है, जैसे कि वे थे

// को कक्षा में ही लागू किया गया था। कार्यक्रम में आगे मैं विस्तार का उपयोग करता हूं

// स्ट्रिंग के लिए arg.FirstChar <string> ()

// एक्सटेंशन सार्वजनिक स्थैतिक होना चाहिए और एक स्थिर वर्ग में बनाया जाना चाहिए

सार्वजनिक स्थैतिक चार्ट फर्स्टचार् <TInput> (यह TInput मान)

// एक्सटेंशन संदर्भ प्रकारों के लिए होगा - जेनेरिक प्रकार C # 2.0 और .net 2.0 के साथ शुरू होते हैं

जहां TInput: वर्ग

{

वापसी मान। StString () [0];

}



स्थिर शून्य मुख्य ()

{

// इनोवेशन - ऐड पद्धति को कॉल करने के स्थान के लिए, आप बस सभी डेटा को निर्दिष्ट कर सकते हैं

// जब एक ऐलान की घोषणा की। इस मामले में भी, तर्क प्रकार सूची <string> के होंगे,

// intellisense इसे समझेगा और सही तरीके से काम करेगा।

var तर्क = नई सूची <string> {"arg_0", "temp_z", "arg_1", "arg_2"};



ऑब्जेक्ट लॉकर;



ताला (लॉकर = नई वस्तु) ()

{

Console.WriteLine ("प्रारंभ");



// लंबोदर अभिव्यक्ति अनिवार्य रूप से एक गुमनाम प्रतिनिधि है। मानक प्रकार

// फंक (रिटर्न पैरामीटर के साथ फ़ंक्शन) आप इनपुट पैरामीटर भी निर्दिष्ट कर सकते हैं

// जो मेरे उदाहरण में आवश्यक नहीं हैं

// लंबोदर अभिव्यक्ति के लिए अनाम प्रतिनिधि बनाया जा सकता है

// (प्रतिनिधि) ()

((फ़ंक <string>) () =>

// यदि कोई कार्य था, तो हम निम्नलिखित लिख सकते हैं:

// Console.WriteLine (((Func <int, int, string>) ((x, y) => (x + y)। ToString ()) (5, 5));

// हम एक लैंबडा एक्सप्रेशन बनाएंगे जिसमें इनपुट पर और आउटपुट पर 2 अंतर पैरामीटर हों

// स्ट्रिंग, और इसे पैरामीटर 5 और 5 के साथ कहेंगे। आप कोशिश कर सकते हैं, यह कंसोल को 10 आउटपुट देगा

// एक गुमनाम प्रतिनिधि का उपयोग करके ऊपर दी गई टिप्पणी में उदाहरण -

// Console.WriteLine (((Func <int, int, string>) (डेलीगेट (int x, int y)) {return (x + y) .ToString ();}) (5, 5));

{

// लैंबडा अभिव्यक्ति की स्थानीय चर तक पहुंच है

// मूल विधि में परिभाषित किया गया है।

ताला (लॉकर)

{

// इस मामले में, परिणाम टाइप स्ट्रिंग का होगा

var result = string.Empty;



foreach (स्ट्रिंग arg in

// लिनक अभिव्यक्ति। परिणाम होगा - IEnumerable <string>

// हम उन सभी मूल्यों के तर्क में देखते हैं जो "arg_" से शुरू होते हैं

// और परिणामस्वरूप हम प्रत्येक पाया से केवल सब्स्ट्रिंग (4) लेते हैं

// परिणाम। IEnumerable <string> सूची <string> या में बदलना आसान है

// string [], इसे जोड़ना काफी आसान है। ToList () या ToArray () अंत में

// इसके अलावा यह अभिव्यक्ति निम्न के समान है -

// तर्क। कहीं भी ((argEntity) => argEntity.StartsWith ("arg_"))।

// चुनें ((argEntity) => argEntity.Substring (4))

// आप यहाँ और अधिक विस्तार से देख सकते हैं - msdn2.microsoft.com/en-us/vcsharp/aa33679.xx

(तर्क में तर्क से

जहाँ argEntity.StartsWith ("arg_")

argEntity.Substring (4)) का चयन करें

{

// लाइनों के पहले अक्षर जोड़ें और परिणाम का परिणाम लौटाएं

Console.WriteLine (परिणाम + = arg.FirstChar <string> ());

}



वापसी परिणाम;

}

}))।

// चूंकि लैम्ब्डा अभिव्यक्ति एक अनाम प्रतिनिधि हो सकती है, इसलिए हम इसे कॉल कर सकते हैं

// एक अलग धागे में

शुरुआत

// एक अनाम डेलीगेट बनाएं जिसे अनुरोध निष्पादित होने पर बुलाया जाएगा,

// इस जगह के लिए एक लंबोदर अभिव्यक्ति लिख सकता है

// (परिणाम) => {

(प्रतिनिधि (IAsyncResult परिणाम) {

Console.WriteLine (

// मक्खी पर एक प्रकार बनाएं जिसमें एक लंबाई की संपत्ति हो,

// यहाँ केवल और अधिक भ्रमित करने के लिए

नई

{

लेंथ = ((फंक <string>) ((AsyncResult) परिणाम) ।AsyncDelegate)।

EndInvoke (परिणाम)। गति

}।

// बेनामी संपत्ति का लेन देन प्राप्त करें

लंबाई);

})

नई वस्तु ()

);



Console.WriteLine ("समाप्त");



Console.ReadKey ();

}



Console.ReadKey ();

}

}

}



// केवल ताले ही बने रहे, लेकिन मैंने उन्हें समझाया नहीं, हर किसी को यह जानना चाहिए ;-)