C# Language
सी # 3.0 सुविधाएँ

टिप्पणियों

अवैध रूप से टाइप किए गए चर (var)

var कीवर्ड प्रोग्रामर को संकलित समय पर एक चर टाइप करने की अनुमति देता है। var घोषणाओं के प्रकार स्पष्ट रूप से घोषित चर के समान होते हैं।

var squaredNumber = 10 * 10;
var squaredNumberDouble = 10.0 * 10.0;
var builder = new StringBuilder();
var anonymousObject = new
{ 
    One = SquaredNumber,
    Two = SquaredNumberDouble,
    Three = Builder
}

इसके बाद के संस्करण चर के प्रकार के होते हैं int , double , StringBuilder , और एक गुमनाम प्रकार क्रमशः।

यह ध्यान रखें कि एक महत्वपूर्ण है var चर गतिशील टाइप नहीं कर रहा है। SquaredNumber = Builder मान्य नहीं है क्योंकि आप एक स्थापित करने के लिए कोशिश कर रहे हैं int की आवृत्ति StringBuilder

भाषा एकीकृत प्रश्न (LINQ)

//Example 1
int[] array = { 1, 5, 2, 10, 7 };

// Select squares of all odd numbers in the array sorted in descending order
IEnumerable<int> query = from x in array
                         where x % 2 == 1
                         orderby x descending
                         select x * x;
// Result: 49, 25, 1

उदाहरण के लिए C # 3.0 पर विकिपीडिया लेख, LINQ उप-भाग

उदाहरण 1 क्वेरी सिंटैक्स का उपयोग करता है जो SQL प्रश्नों के समान दिखने के लिए डिज़ाइन किया गया था।

//Example 2
IEnumerable<int> query = array.Where(x => x % 2 == 1)
    .OrderByDescending(x => x)
    .Select(x => x * x);
// Result: 49, 25, 1 using 'array' as defined in previous example

उदाहरण के लिए C # 3.0 पर विकिपीडिया लेख, LINQ उप-भाग

उदाहरण 2 उदाहरण 1 के समान परिणाम प्राप्त करने के लिए विधि सिंटैक्स का उपयोग करता है।

यह ध्यान रखना महत्वपूर्ण है कि, C # में, LINQ विधि वाक्यविन्यास के लिए LINQ क्वेरी वाक्यविन्यास वाक्यगत शर्करा है । कंपाइलर प्रश्नों का संकलन समय पर विधि कॉल में करता है। कुछ प्रश्नों को विधि सिंटैक्स में व्यक्त किया जाना है। MSDN से - "उदाहरण के लिए, आपको क्वेरी को व्यक्त करने के लिए एक विधि कॉल का उपयोग करना चाहिए जो निर्दिष्ट स्थिति से मेल खाने वाले तत्वों की संख्या को पुनः प्राप्त करता है।"

लम्बोदर एक्सपेक्टेशन

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

using System;
using System.Collections.Generic;
using System.Linq;
                    
public class Program
{
    public static void Main()
    {
        var numberList = new List<int> {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        var sumOfSquares = numberList.Select( number => number * number )
            .Aggregate( (int first, int second) => { return first + second; } );
        Console.WriteLine( sumOfSquares );
    }
}

उपरोक्त कोड कंसोल के 10 के माध्यम से संख्या 1 के वर्गों का योग आउटपुट करेगा।

सूची में संख्याओं को पहले लैंबडा अभिव्यक्ति वर्ग। चूंकि केवल 1 पैरामीटर कोष्ठक छोड़ा जा सकता है। यदि आप चाहें तो आप कोष्ठक शामिल कर सकते हैं:

.Select( (number) => number * number);

या स्पष्ट रूप से पैरामीटर टाइप करें लेकिन फिर कोष्ठक की आवश्यकता होती है:

.Select( (int number) => number * number);

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

.Select( number => { return number * number; } );

चयनित विधि गणना मूल्यों के साथ एक नया IEnumerable देता है।

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

.Aggregate( (first, second) => { return first + second; } );

जैसा कि यह एक है:

.Aggregate( (int first, int second) => first + second );

अनाम प्रकार

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

आप घुंघराले ब्रेस ( { ) के बाद new कीवर्ड का उपयोग करके गुमनाम प्रकार बना सकते हैं। घुंघराले ब्रेसिज़ के अंदर, आप नीचे दिए कोड की तरह गुणों को परिभाषित कर सकते हैं।

var v = new { Amount = 108, Message = "Hello" };

अनाम प्रकारों की एक सरणी बनाना भी संभव है। नीचे कोड देखें:

var a = new[] { 
    new { 
        Fruit = "Apple", 
        Color = "Red" 
    },
    new {
        Fruit = "Banana",
        Color = "Yellow"
    }
};

या LINQ प्रश्नों के साथ इसका उपयोग करें:

var productQuery = from prod in products
                   select new { prod.Color, prod.Price };