C# Language
वस्तुओं के लिए Linq

परिचय

कैसे LINQ ऑब्जेक्ट को निष्पादित करता है

LINQ क्वेरी तुरंत निष्पादित नहीं होती है। जब आप क्वेरी का निर्माण कर रहे होते हैं, तो आप भविष्य के निष्पादन के लिए क्वेरी को स्टोर कर रहे होते हैं। जब आप वास्तव में क्वेरी को पुनरावृत्त करने का अनुरोध करते हैं, तो क्वेरी निष्पादित होती है (उदाहरण के लिए लूप के लिए, जब कॉल करने के लिए टॉलिस्ट, काउंट, मैक्स, औसत, प्रथम, आदि)

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

कोड दिया:

var query = from n in numbers 
            where n % 2 != 0
            select n;

ऊपर का उदाहरण केवल क्वेरी को query चर में संग्रहीत करता है। यह क्वेरी को स्वयं निष्पादित नहीं करता है।

foreach स्टेटमेंट क्वेरी के निष्पादन पर बल देता है:

foreach(var n in query) {
    Console.WriteLine($"Number selected {n}");
}

कुछ LINQ विधियाँ क्वेरी निष्पादन, Count , First , Max , Average को भी गति प्रदान करेंगी। वे एकल मान लौटाते हैं। ToList और ToArray परिणाम एकत्र करता है और उन्हें क्रमशः एक सूची या सरणी में बदल देता है।

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

LINQ का उपयोग C # में ऑब्जेक्ट्स के लिए करना

Linq में एक सरल चयन क्वेरी

static void Main(string[] args)
{
    string[] cars = { "VW Golf", 
                        "Opel Astra", 
                        "Audi A4", 
                        "Ford Focus", 
                        "Seat Leon", 
                        "VW Passat", 
                        "VW Polo", 
                        "Mercedes C-Class" };

    var list = from car in cars
               select car;

    StringBuilder sb = new StringBuilder();

    foreach (string entry in list)
    {
        sb.Append(entry + "\n");
    }

    Console.WriteLine(sb.ToString());
    Console.ReadLine();
}

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

जब उपरोक्त कोड संकलित और निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है:

WHERE क्लॉज के साथ चयन करें

var list = from car in cars
           where car.Contains("VW")
           select car;

WHERE क्लॉज का उपयोग स्ट्रिंग ऐरे (कारों) को क्वेरी करने के लिए किया जाता है और एरे के एक सबसेट को खोजने के लिए जो WHERE क्लॉज को संतुष्ट करता है।

जब उपरोक्त कोड संकलित और निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है:

एक ऑर्डर की गई सूची बनाना

var list = from car in cars
           orderby car ascending 
           select car;

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

जब उपरोक्त कोड संकलित और निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है:

एक कस्टम प्रकार के साथ काम करना

इस उदाहरण में, एक टाइप की गई सूची बनाई जाती है, आबादी होती है, और फिर क्वेरी की जाती है

public class Car
{
    public String Name { get; private set; }
    public int UnitsSold { get; private set; }

    public Car(string name, int unitsSold)
    {
        Name = name;
        UnitsSold = unitsSold;
    }
}

class Program
{
    static void Main(string[] args)
    {

        var car1 = new Car("VW Golf", 270952);
        var car2 = new Car("Opel Astra", 56079);
        var car3 = new Car("Audi A4", 52493);
        var car4 = new Car("Ford Focus", 51677);
        var car5 = new Car("Seat Leon", 42125);
        var car6 = new Car("VW Passat", 97586);
        var car7 = new Car("VW Polo", 69867);
        var car8 = new Car("Mercedes C-Class", 67549);

        var cars = new List<Car> { 
            car1, car2, car3, car4, car5, car6, car7, car8 };
        var list = from car in cars
                   select car.Name;

        foreach (var entry in list)
        {
            Console.WriteLine(entry);
        }
        Console.ReadLine();
    }
}

जब उपरोक्त कोड संकलित और निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है:

अब तक के उदाहरण आश्चर्यजनक नहीं लगते हैं क्योंकि मूल रूप से एक ही करने के लिए एक सरणी के माध्यम से बस पुनरावृति हो सकती है। हालांकि, नीचे दिए गए कुछ उदाहरणों के साथ आप देख सकते हैं कि LINQ के साथ ऑब्जेक्ट्स के लिए और अधिक जटिल क्वेरी कैसे बनाएं और बहुत कम कोड के साथ अधिक प्राप्त करें।

नीचे दिए गए उदाहरण में हम उन कारों का चयन कर सकते हैं जो 60000 से अधिक इकाइयों में बेची गई हैं और उन्हें बेची गई इकाइयों की संख्या से अधिक है:

var list = from car in cars
           where car.UnitsSold > 60000 
           orderby car.UnitsSold descending 
           select car;

StringBuilder sb = new StringBuilder();

foreach (var entry in list)
{
    sb.AppendLine($"{entry.Name} - {entry.UnitsSold}");
}
Console.WriteLine(sb.ToString());

जब उपरोक्त कोड संकलित और निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है:

नीचे दिए गए उदाहरण में हम उन कारों का चयन कर सकते हैं जिन्होंने विषम संख्या में इकाइयाँ बेची हैं और इसके नाम पर वर्णानुक्रम में उन्हें क्रमबद्ध किया है:

var list = from car in cars
           where car.UnitsSold % 2 != 0 
           orderby car.Name ascending 
           select car;

जब उपरोक्त कोड संकलित और निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है: